package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.base.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.AddMemoryBusinessSetDataComReqDto;
import com.wicket.okrapp.biz.service.dto.req.QueryMemoryBusinessDataSetDetailComReqDto;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.biz.service.dto.res.AddMemoryBusinessSetDataComRespDto;
import com.wicket.okrapp.biz.service.dto.res.QueryMemoryBusinessDataSetDetailComRespDto;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.*;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerListComReqDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrapp.dal.po.mbg.OmsExecuteCycleStage;

import java.util.ArrayList;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbCustomExecutionCycle;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.MOmsCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsCycle;
import com.wicket.okrapp.base.service.MOmsTargetCyclePlanSetService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCyclePlanSet;
import com.wicket.okrapp.biz.service.dto.common.TargetCyclePsetDto;
import com.wicket.okrapp.biz.service.TargetContentService;

import com.wicket.okrapp.biz.service.TargetCycleService;
import com.wicket.okrapp.biz.service.OffStateService;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrapp.base.service.MOmsEvaCycleConfService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaCycleConf;
//import com.wicket.okrcalc.integration.dto.DataSetsListOneDto;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerListComReqDto;
import com.wicket.okrapp.biz.service.dto.common.TargetContPlanWorkTimeDto;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerListComReqDto;
import com.wicket.okrapp.biz.service.dto.common.ExecuteCycleStageDto;
import com.wicket.okrapp.biz.service.CycleConfService;
import com.wicket.okrapp.base.service.MOmsCycleTimeRuleService;
import com.wicket.okrapp.dal.po.mbg.OmsCycleTimeRule;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationTemplate;
import com.wicket.okrapp.biz.service.CycleTypeService;
import com.wicket.okrapp.biz.service.TaskGenService;
import com.wicket.okrapp.biz.service.dto.common.TemplateOpenCycleTypeDto;
import com.wicket.okrapp.biz.service.dto.common.WorkDaysTwoMonthsDto;
import com.wicket.okrapp.base.service.MOmsExecuteProgressService;
import com.wicket.okrapp.biz.service.ExecuteProgressService;
import com.wicket.okrapp.base.service.MOmsTaskService;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.biz.service.ExecuteCycleService;
import com.wicket.okrapp.base.service.MOmsTargetService;
import com.wicket.okrapp.dal.po.mbg.OmsTarget;
import com.wicket.okrapp.base.service.MOmsTargetAttributionCycleService;
import com.wicket.okrapp.biz.service.dto.common.SubCycleDto;
import com.wicket.okrapp.biz.service.TargetCalcService;
import com.wicket.okrapp.base.service.MOmsTargetTimingTaskDispatchService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetTimingTaskDispatch;
import com.wicket.okrapp.biz.service.TargetContComService;
import com.wicket.okrapp.biz.service.EvaThemeService;
import com.wicket.okrapp.biz.service.BusinessAtomService;
import com.wicket.okrapp.biz.service.dto.common.CycleDto;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class CustomExecutionCycleServiceImpl
  implements com.wicket.okrapp.biz.service.CustomExecutionCycleService {

  @Resource
  private RedisUtil redisUtil;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
@Resource
  private NbCustomExecutionCycle nbCustomExecutionCycle;
@Resource
  private FwCompDivineDataClient fwCompDivineDataClient;
@Resource
  private FwCompSchemeOpenRecordClient fwCompSchemeOpenRecordClient;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private MOmsCycleService mOmsCycleService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private MOmsTargetCyclePlanSetService mOmsTargetCyclePlanSetService;
@Resource
  private TargetContentService targetContentService;
    @Resource
    private FwCompBusinessAtomClient fwCompBusinessAtomClient;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private OffStateService offStateService;
@Resource
  private MOmsEvaCycleConfService mOmsEvaCycleConfService;
@Resource
  private CycleConfService cycleConfService;
@Resource
  private MOmsCycleTimeRuleService mOmsCycleTimeRuleService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private CycleTypeService cycleTypeService;
@Resource
  private TaskGenService taskGenService;
@Resource
  private MOmsExecuteProgressService mOmsExecuteProgressService;
@Resource
  private ExecuteProgressService executeProgressService;
@Resource
  private FwCompTemplateEngineClient fwCompTemplateEngineClient;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private ExecuteCycleService executeCycleService;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
  private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
@Resource
  private TargetContComService targetContComService;
@Resource
  private EvaThemeService evaThemeService;
@Resource
  private BusinessAtomService businessAtomService;
//@Resource
 //private MCustomFields5Service mCustomFields5Service;
//@Resource
 //private undefinedService undefinedService;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
//@Resource
 //private MOmsConfSchemeOptionResultService mOmsConfSchemeOptionResultService;
/**
   * D3删除目标内容执行周期(公共)[6648]
   * gen by moon at 5/13/2023, 9:32:15 PM
   */
  @Trace(operationName = "D3删除目标内容执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public DeleteTargetContenteExecutionCycleComRespDto deleteTargetContenteExecutionCycleCom(DeleteTargetContenteExecutionCycleComReqDto reqDto){
    
      
      //步骤0: M3执行接收字段入参（特殊方法） - implementAcceptField
     //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:936436_1
    }
  
    /*M3执行接收字段入参（特殊方法）[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3删除目标内容执行周期(公共)-M3执行接收字段入参（特殊方法）-被评对象目标周期ID不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementAcceptField(receptionServiceReq);
      
      
      
    
//步骤1: 3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于） - queryExecuteCycleStageList
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleStageListReq queryExecuteCycleStageListReq=new QueryExecuteCycleStageListReq();
  queryExecuteCycleStageListReq.setIsDefinedExecuteCycleStage("TRUE");//sourceId:936365_1
queryExecuteCycleStageListReq.setSubjectLifeCycle("EDITING");//sourceId:936442_1
if(reqDto!=null){
      queryExecuteCycleStageListReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:936364_1
    }
  
    /*3-3-07查询执行周期阶段列表[3201]   */
    Assert.isNull(queryExecuteCycleStageListReq.getEvaObjTargetCycleId(),"D3删除目标内容执行周期(公共)-3-3-07查询执行周期阶段列表-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsDefinedExecuteCycleStage(),"D3删除目标内容执行周期(公共)-3-3-07查询执行周期阶段列表-是否自定义执行周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getSubjectLifeCycle(),"D3删除目标内容执行周期(公共)-3-3-07查询执行周期阶段列表-主体生命周期不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
    
//步骤2: 3-3-07批量删执行周期阶段 - batchDeleteExecuteCycleStage
     boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listString = listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:936368_1
    }
  
    /*3-3-07批量删执行周期阶段[2743]   */
    
      bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;
      
      
      
           }
    
DeleteTargetContenteExecutionCycleComRespDto retData = new DeleteTargetContenteExecutionCycleComRespDto();
  
  

  
  
return retData;
  }
/**
   * D3-执行根据自定义分析父周期(公共)[6654]
   * gen by moon at 5/14/2023, 5:03:32 PM
   */
  @Trace(operationName = "D3-执行根据自定义分析父周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto implementExecuteFatherCycleAnalysisByCustomizeCom(ImplementExecuteFatherCycleAnalysisByCustomizeComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 =null;
//virtualUsage 约定：是  41607
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:938508_1_41607

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-执行根据自定义分析父周期(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 约定：否  41608
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:938509_1_41608

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-执行根据自定义分析父周期(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);



//virtualUsage D2检查时间范围查询(公共)  41602
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:937901_1_41602
checkTimeScopeSearchComReqDto.setCompareTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:937903_1_41602
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
        //if(D2父周期开始时间分析.时间比较结果 等于 当前（等于）)  41603

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_2.setFatherCycleStartTimeIsModify(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:938519_1_41606
    }

    /*约定出参：父周期开始时间是否定制[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getFatherCycleStartTimeIsModify(),"D3-执行根据自定义分析父周期(公共)-约定出参：父周期开始时间是否定制-父周期开始时间是否定制不能为空",false);
      receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))){
       //elseif(D2父周期开始时间分析.时间比较结果 等于 之后（大于）)  41604

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setFatherCycleStartTimeIsModify(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:938519_1_41605
    }

    /*约定出参：父周期开始时间是否定制[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getFatherCycleStartTimeIsModify(),"D3-执行根据自定义分析父周期(公共)-约定出参：父周期开始时间是否定制-父周期开始时间是否定制不能为空",false);
      receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_6;
    }
//virtualUsage D2检查时间范围查询(公共)  41609
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:937901_1_41609
checkTimeScopeSearchComReqDto_1.setCompareTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:937903_1_41609
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3-执行根据自定义分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
        //if(D2父周期结束时间分析.时间比较结果 等于 当前（等于）)  41610

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_4.setFatherCycleEndTimeIsModify(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:938521_1_41611
    }

    /*约定出参：父周期结束时间是否定制[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_7 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_8 = receptionServiceRes_7;
      }
else if((checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE"))){
       //elseif(D2父周期结束时间分析.时间比较结果 等于 之前（小于）)  41613

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setFatherCycleEndTimeIsModify(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:938521_1_41614
    }

    /*约定出参：父周期结束时间是否定制[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_9 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_8 = receptionServiceRes_9;
    }
ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto retData = new ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setFatherCycleStartTimeIsModify(receptionServiceRes_5.getFatherCycleStartTimeIsModify());//SimpleFieldAssign//sourceId:938544_1
    }
if(receptionServiceRes_8!=null){
      retData.setFatherCycleEndTimeIsModify(receptionServiceRes_8.getFatherCycleEndTimeIsModify());//SimpleFieldAssign//sourceId:938545_1
    }




return retData;
  }
/**
   * D3-执行回删过程执行周期(公共)[6658]
   * gen by moon at 5/14/2023, 3:01:47 AM
   */
  @Trace(operationName = "D3-执行回删过程执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDeletProgressCycleComRespDto implementDeletProgressCycleCom(ImplementDeletProgressCycleComReqDto reqDto){


      //virtualUsage 3-3-07-查询执行周期列表（开始大于等于&结束小于）  41656
      List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleGreaterAndEqualStartListReq queryExecuteCycleGreaterAndEqualStartListReq=new QueryExecuteCycleGreaterAndEqualStartListReq();
  queryExecuteCycleGreaterAndEqualStartListReq.setIsProcessCycleStage("TRUE");//sourceId:939166_1_41656
queryExecuteCycleGreaterAndEqualStartListReq.setIsArchive("FALSE");//sourceId:939168_1_41656
if(reqDto!=null){
      queryExecuteCycleGreaterAndEqualStartListReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939161_1_41656
queryExecuteCycleGreaterAndEqualStartListReq.setCycleEndTime(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:939162_1_41656
queryExecuteCycleGreaterAndEqualStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939288_1_41656
    }

    /*3-3-07-查询执行周期列表（开始大于等于&结束小于）[6660]   */
    Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsProcessCycleStage(),"D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsArchive(),"D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getEvaluationTemplateId(),"D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleGreaterAndEqualStartList(queryExecuteCycleGreaterAndEqualStartListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage!= null&&  listOmsExecuteCycleStage !=null && listOmsExecuteCycleStage.size()>0)) {
        //if(3-3-07-查询定制开始时间与父周期开始时间范围.执行周期阶段列表数据集条数 大于 0)  41657

boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listString = listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:938959_1_41658
    }

    /*3-3-07批量删执行周期阶段[2743]   */

//      bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
//virtualUsage 3-3-07-查询执行周期列表（开始大于&结束小于等于）  41659
      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 =new ArrayList<>();
    QueryExecuteCycleGreaterStartListReq queryExecuteCycleGreaterStartListReq=new QueryExecuteCycleGreaterStartListReq();
  queryExecuteCycleGreaterStartListReq.setIsProcessCycleStage("TRUE");//sourceId:939278_1_41659
queryExecuteCycleGreaterStartListReq.setIsArchive("FALSE");//sourceId:939280_1_41659
if(reqDto!=null){
      queryExecuteCycleGreaterStartListReq.setCycleStartTime(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:939276_1_41659
queryExecuteCycleGreaterStartListReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939277_1_41659
queryExecuteCycleGreaterStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939279_1_41659
    }

    /*3-3-07-查询执行周期列表（开始大于&结束小于等于）[6661]   */
    Assert.isNull(queryExecuteCycleGreaterStartListReq.getIsProcessCycleStage(),"D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于&结束小于等于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleGreaterStartListReq.getIsArchive(),"D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于&结束小于等于）-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleGreaterStartListReq.getEvaluationTemplateId(),"D3-执行回删过程执行周期(公共)-3-3-07-查询执行周期列表（开始大于&结束小于等于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleGreaterStartList(queryExecuteCycleGreaterStartListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage_2!= null&&  listOmsExecuteCycleStage_2 !=null && listOmsExecuteCycleStage_2.size()>0)) {
        //if(3-3-07-查询定制结束时间与父周期结束时间范围.执行周期阶段列表数据集条数 大于 0)  41660

boolean bOOLEAN_1 ;
    if(listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&& listOmsExecuteCycleStage_2.size()>0 ){
          List<String> listString_1=new ArrayList<>();
  if(listOmsExecuteCycleStage_2!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&&  listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)){
      listString_1 = listOmsExecuteCycleStage_2.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:938959_1_41661
    }

    /*3-3-07批量删执行周期阶段[2743]   */

//      bOOLEAN_1 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString_1)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
ImplementDeletProgressCycleComRespDto retData = new ImplementDeletProgressCycleComRespDto();





return retData;
  }
/**
   * D3执行回写模板自定义执行周期起止时间定制答案(公共)[6659]
   * gen by moon at 5/14/2023, 3:02:00 AM
   */
  @Trace(operationName = "D3执行回写模板自定义执行周期起止时间定制答案(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWriteBackstartAndEndTimeCustomResultComRespDto implementWriteBackstartAndEndTimeCustomResultCom(ImplementWriteBackstartAndEndTimeCustomResultComReqDto reqDto){


      //virtualUsage 3-3-09查目标父周期开始与结束时间  41631
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:939248_1_41631
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:939249_1_41631
queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:939250_1_41631
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:939251_1_41631
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:939253_1_41631
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getApplexId());//SimpleFieldAssign//sourceId:939252_1_41631
    }

    /*3-3-09查目标父周期开始与结束时间[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-3-3-09查目标父周期开始与结束时间-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D2检查时间范围查询(公共)  41632
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939283_1_41632
    }
if(omsEvaluationObjectTargetCycle!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939285_1_41632
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((!(checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")))) {
        //if(D2比较开始时间是否相同.时间比较结果 不等于 当前（等于）)  41633

ImplementWriteBackSingleCustomResultComRespDto implementWriteBackSingleCustomResultComRespDto = null;
    ImplementWriteBackSingleCustomResultComReqDto implementWriteBackSingleCustomResultComReqDto=new ImplementWriteBackSingleCustomResultComReqDto();
  implementWriteBackSingleCustomResultComReqDto.setConfOptionCode("START_TIME");//CUSTOM_CONVENTION//sourceId:938961_1_41634
implementWriteBackSingleCustomResultComReqDto.setConfItemCode("EVAL_SPECIAL_START_TIME_AND_END_TIME");//CUSTOM_CONVENTION//sourceId:938962_1_41634
if(reqDto!=null){
      implementWriteBackSingleCustomResultComReqDto.setApplexId(reqDto.getApplexId());//SimpleFieldAssign//sourceId:938960_1_41634
implementWriteBackSingleCustomResultComReqDto.setEndValue(reqDto.getCycleStartTime()!=null?String.valueOf(reqDto.getCycleStartTime()):"");//SimpleFieldAssign//sourceId:938963_1_41634
    }

    /*D2执行回写单条定制答案(开始时间)[6653]   */
    Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getApplexId(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-开通对象ID不能为空",false);
Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getEndValue(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-答案值不能为空",false);
Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getConfOptionCode(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-选项标识不能为空",false);
Assert.isNull(implementWriteBackSingleCustomResultComReqDto.getConfItemCode(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(开始时间)-配置项标识不能为空",false);
      implementWriteBackSingleCustomResultComRespDto = fwCompSchemeOpenRecordClient.implementWriteBackSingleCustomResultCom(implementWriteBackSingleCustomResultComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
//virtualUsage D2检查时间范围查询(公共)  41638
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939283_1_41638
    }
if(omsEvaluationObjectTargetCycle!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939285_1_41638
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((!(checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
        //if(D2比较结束时间是否相同.时间比较结果 不等于 当前（等于）)  41639

ImplementWriteBackSingleCustomResultComRespDto implementWriteBackSingleCustomResultComRespDto_1 = null;
    ImplementWriteBackSingleCustomResultComReqDto implementWriteBackSingleCustomResultComReqDto_1=new ImplementWriteBackSingleCustomResultComReqDto();
  implementWriteBackSingleCustomResultComReqDto_1.setConfOptionCode("END_TIME");//CUSTOM_CONVENTION//sourceId:939137_1_41640
implementWriteBackSingleCustomResultComReqDto_1.setConfItemCode("EVAL_SPECIAL_START_TIME_AND_END_TIME");//CUSTOM_CONVENTION//sourceId:939138_1_41640
if(reqDto!=null){
      implementWriteBackSingleCustomResultComReqDto_1.setApplexId(reqDto.getApplexId());//SimpleFieldAssign//sourceId:939136_1_41640
implementWriteBackSingleCustomResultComReqDto_1.setEndValue(reqDto.getCycleEndTime()!=null?String.valueOf(reqDto.getCycleEndTime()):"");//SimpleFieldAssign//sourceId:939139_1_41640
    }

    /*D2执行回写单条定制答案(结束时间)[6653]   */
    Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getApplexId(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-开通对象ID不能为空",false);
Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getEndValue(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-答案值不能为空",false);
Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getConfOptionCode(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-选项标识不能为空",false);
Assert.isNull(implementWriteBackSingleCustomResultComReqDto_1.getConfItemCode(),"D3执行回写模板自定义执行周期起止时间定制答案(公共)-D2执行回写单条定制答案(结束时间)-配置项标识不能为空",false);
      implementWriteBackSingleCustomResultComRespDto_1 = fwCompSchemeOpenRecordClient.implementWriteBackSingleCustomResultCom(implementWriteBackSingleCustomResultComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
ImplementWriteBackstartAndEndTimeCustomResultComRespDto retData = new ImplementWriteBackstartAndEndTimeCustomResultComRespDto();





return retData;
  }
/**
   * D3-执行周期补偿处理(公共)[6662]
   * gen by moon at 5/14/2023, 10:23:15 PM
   */
  @Trace(operationName = "D3-执行周期补偿处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExecuteCycleCompensationComRespDto implementExecuteCycleCompensationCom(ImplementExecuteCycleCompensationComReqDto reqDto){


      //virtualUsage 是否开启评价模板自定义执行周期起止时间  41645
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:939511_1_41645
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SPECIAL_START_TIME_AND_END_TIME");//CUSTOM_CONVENTION//sourceId:939510_1_41645
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:939519_1_41645
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939512_1_41645
    }

    /*是否开启评价模板自定义执行周期起止时间[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(),"D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-开通对象类型编码不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-执行周期补偿处理(公共)-是否开启评价模板自定义执行周期起止时间-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage 3-3-09查被评对象目标周期详情  41653
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:939744_1_41653
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:939746_1_41653
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939745_1_41653
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行周期补偿处理(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3-执行周期补偿处理(公共)-3-3-09查被评对象目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行周期补偿处理(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE"))) {
        //if(是否开启评价模板自定义执行周期起止时间.答案值 等于 是)  41646

ImplementExecuteFatherCycleAnalysisByCustomizeComRespDto implementExecuteFatherCycleAnalysisByCustomizeComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementExecuteFatherCycleAnalysisByCustomizeComReqDto implementExecuteFatherCycleAnalysisByCustomizeComReqDto=new ImplementExecuteFatherCycleAnalysisByCustomizeComReqDto();
  if(reqDto!=null){
      implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:939294_1_41648
implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:939295_1_41648
implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939296_1_41648
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939754_1_41648
implementExecuteFatherCycleAnalysisByCustomizeComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939755_1_41648
    }

    /*D3-执行根据自定义分析父周期(公共)[6654]   */
    Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getComTimeField1(),"D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-前端录入父周期开始时间不能为空",false);
Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getComTimeField2(),"D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-前端录入父周期结束时间不能为空",false);
Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getCycleStartTime(),"D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-父周期周期开始时间不能为空",false);
Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getCycleEndTime(),"D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-父周期周期结束时间不能为空",false);
Assert.isNull(implementExecuteFatherCycleAnalysisByCustomizeComReqDto.getEvaluationTemplateId(),"D3-执行周期补偿处理(公共)-D3-执行根据自定义分析父周期(公共)-冗余评价模板ID不能为空",false);
      implementExecuteFatherCycleAnalysisByCustomizeComRespDto = implementExecuteFatherCycleAnalysisByCustomizeCom(implementExecuteFatherCycleAnalysisByCustomizeComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((implementExecuteFatherCycleAnalysisByCustomizeComRespDto!= null&&  implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleStartTimeIsModify() !=null && implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleStartTimeIsModify().equals("TRUE")||implementExecuteFatherCycleAnalysisByCustomizeComRespDto!= null&&  implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleEndTimeIsModify() !=null && implementExecuteFatherCycleAnalysisByCustomizeComRespDto.getFatherCycleEndTimeIsModify().equals("TRUE"))) {
        //if((D3-执行周期父周期分析(公共).父周期开始时间是否定制 等于 是 or D3-执行周期父周期分析(公共).父周期结束时间是否定制 等于 是))  41649

ImplementDeletProgressCycleComRespDto implementDeletProgressCycleComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementDeletProgressCycleComReqDto implementDeletProgressCycleComReqDto=new ImplementDeletProgressCycleComReqDto();
  if(reqDto!=null){
      implementDeletProgressCycleComReqDto.setComTimeField1(reqDto.getComTimeField1());//SimpleFieldAssign//sourceId:939301_1_41650
implementDeletProgressCycleComReqDto.setComTimeField2(reqDto.getComTimeField2());//SimpleFieldAssign//sourceId:939302_1_41650
implementDeletProgressCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939305_1_41650
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementDeletProgressCycleComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939303_1_41650
implementDeletProgressCycleComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939304_1_41650
    }

    /*D3-执行回删过程执行周期(公共)[6658]   */
    Assert.isNull(implementDeletProgressCycleComReqDto.getCycleStartTime(),"D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期开始时间不能为空",false);
Assert.isNull(implementDeletProgressCycleComReqDto.getCycleEndTime(),"D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期结束时间不能为空",false);
Assert.isNull(implementDeletProgressCycleComReqDto.getEvaluationTemplateId(),"D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-评价模板ID不能为空",false);
      implementDeletProgressCycleComRespDto = implementDeletProgressCycleCom(implementDeletProgressCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
      }
else if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("FALSE"))){
       //elseif(是否开启评价模板自定义执行周期起止时间.答案值 等于 否)  41647

ImplementExecuteFatherCycleAnalysisByHolidayComRespDto implementExecuteFatherCycleAnalysisByHolidayComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementExecuteFatherCycleAnalysisByHolidayComReqDto implementExecuteFatherCycleAnalysisByHolidayComReqDto=new ImplementExecuteFatherCycleAnalysisByHolidayComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementExecuteFatherCycleAnalysisByHolidayComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:940327_1_41673
implementExecuteFatherCycleAnalysisByHolidayComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:940328_1_41673
    }

    /*D3-执行根据节假日分析父周期(公共)[6665]   */
    Assert.isNull(implementExecuteFatherCycleAnalysisByHolidayComReqDto.getCycleStartTime(),"D3-执行周期补偿处理(公共)-D3-执行根据节假日分析父周期(公共)-父周期周期开始时间不能为空",false);
Assert.isNull(implementExecuteFatherCycleAnalysisByHolidayComReqDto.getCycleEndTime(),"D3-执行周期补偿处理(公共)-D3-执行根据节假日分析父周期(公共)-父周期周期结束时间不能为空",false);
      implementExecuteFatherCycleAnalysisByHolidayComRespDto = implementExecuteFatherCycleAnalysisByHolidayCom(implementExecuteFatherCycleAnalysisByHolidayComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementDeletProgressCycleComRespDto implementDeletProgressCycleComRespDto_1 = null;
    if(implementExecuteFatherCycleAnalysisByHolidayComRespDto !=null&&omsEvaluationObjectTargetCycle !=null){
          ImplementDeletProgressCycleComReqDto implementDeletProgressCycleComReqDto_1=new ImplementDeletProgressCycleComReqDto();
  if(implementExecuteFatherCycleAnalysisByHolidayComRespDto!=null){
      implementDeletProgressCycleComReqDto_1.setComTimeField1(implementExecuteFatherCycleAnalysisByHolidayComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939301_1_41674
implementDeletProgressCycleComReqDto_1.setComTimeField2(implementExecuteFatherCycleAnalysisByHolidayComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939302_1_41674
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementDeletProgressCycleComReqDto_1.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939303_1_41674
implementDeletProgressCycleComReqDto_1.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:939304_1_41674
    }
if(reqDto!=null){
      implementDeletProgressCycleComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:939305_1_41674
    }

    /*D3-执行回删过程执行周期(公共)[6658]   */
    Assert.isNull(implementDeletProgressCycleComReqDto_1.getCycleStartTime(),"D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期开始时间不能为空",false);
Assert.isNull(implementDeletProgressCycleComReqDto_1.getCycleEndTime(),"D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-父周期周期结束时间不能为空",false);
Assert.isNull(implementDeletProgressCycleComReqDto_1.getEvaluationTemplateId(),"D3-执行周期补偿处理(公共)-D3-执行回删过程执行周期(公共)-评价模板ID不能为空",false);
      implementDeletProgressCycleComRespDto_1 = implementDeletProgressCycleCom(implementDeletProgressCycleComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
    }
ImplementExecuteCycleCompensationComRespDto retData = new ImplementExecuteCycleCompensationComRespDto();





return retData;
  }
/**
   * D3-执行根据节假日分析父周期(公共)[6665]
   * gen by moon at 5/14/2023, 6:20:07 PM
   */
  @Trace(operationName = "D3-执行根据节假日分析父周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExecuteFatherCycleAnalysisByHolidayComRespDto implementExecuteFatherCycleAnalysisByHolidayCom(ImplementExecuteFatherCycleAnalysisByHolidayComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
//virtualUsage 3-4-04查询最小周期（标准工作日）  41662
      OmsCycle omsCycle = null;
    QueryMinimumCycleDetailReq queryMinimumCycleDetailReq=new QueryMinimumCycleDetailReq();
  queryMinimumCycleDetailReq.setCycleTypeCode("WEEKDAY");//CUSTOM_CONVENTION//sourceId:939960_1_41662
queryMinimumCycleDetailReq.setCycleTypeStandard("STANDARD");//sourceId:939978_1_41662
queryMinimumCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:939963_1_41662
if(reqDto!=null){
      queryMinimumCycleDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939958_1_41662
queryMinimumCycleDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939959_1_41662
    }

    /*3-4-04查询最小周期（标准工作日）[6663]   */
    Assert.isNull(queryMinimumCycleDetailReq.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-周期开始时间不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-周期结束时间不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq.getCycleTypeCode(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-周期类型标识不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq.getSubjectLifeCycle(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（标准工作日）-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryMinimumCycleDetail(queryMinimumCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-4-04查询最小周期（自定义工作日）  41664
      OmsCycle omsCycle_2 = null;
    QueryMinimumCycleDetailReq queryMinimumCycleDetailReq_1=new QueryMinimumCycleDetailReq();
  queryMinimumCycleDetailReq_1.setCycleTypeCode("CUSTOM_WEEKDAY");//CUSTOM_CONVENTION//sourceId:940002_1_41664
queryMinimumCycleDetailReq_1.setCycleTypeStandard("IRREGULAR");//sourceId:940019_1_41664
queryMinimumCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:940005_1_41664
queryMinimumCycleDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:940818_1_41664
if(reqDto!=null){
      queryMinimumCycleDetailReq_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:940000_1_41664
queryMinimumCycleDetailReq_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:940001_1_41664
    }

    /*3-4-04查询最小周期（自定义工作日）[6663]   */
    Assert.isNull(queryMinimumCycleDetailReq_1.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-周期开始时间不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq_1.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-周期结束时间不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq_1.getCycleTypeCode(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-周期类型标识不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq_1.getCycleTypeStandard(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-冗余周期类型标准化不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq_1.getSubjectLifeCycle(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-主体生命周期不能为空",false);
Assert.isNull(queryMinimumCycleDetailReq_1.getSpaceId(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最小周期（自定义工作日）-创建于空间ID不能为空",false);
      omsCycle_2 = mOmsCycleService.queryMinimumCycleDetail(queryMinimumCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



if((omsCycle_2 == null )) {
        //if(3-4-04查询最小周期（自定义工作日）.出参 值等于空 )  41701

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(omsCycle !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(omsCycle!=null){
      receptionServiceReq.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:940181_1_41702
    }

    /*约定出参：周期开始时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-约定出参：周期开始时间-周期开始时间不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
//virtualUsage D2检查时间范围查询(公共)  41665
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsCycle !=null&&omsCycle_2 !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(omsCycle!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:939955_1_41665
    }
if(omsCycle_2!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:939957_1_41665
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
        //if((D2标准工作日与自定义工作日最小比较.时间比较结果 等于 之前（小于） or D2标准工作日与自定义工作日最小比较.时间比较结果 等于 当前（等于）))  41666

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(omsCycle !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(omsCycle!=null){
      receptionServiceReq_1.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:940181_1_41669
    }

    /*约定出参：周期开始时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-约定出参：周期开始时间-周期开始时间不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
      }
else if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))){
       //elseif(D2标准工作日与自定义工作日最小比较.时间比较结果 等于 之后（大于）)  41697

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
    if(omsCycle_2 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(omsCycle_2!=null){
      receptionServiceReq_2.setCycleStartTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:940181_1_41698
    }

    /*约定出参：周期开始时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-约定出参：周期开始时间-周期开始时间不能为空",false);
      receptionServiceRes_3 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
      }
//virtualUsage 3-4-04查询最大周期（标准工作日）  41667
      OmsCycle omsCycle_4 = null;
    QueryMaximumCycleDetailReq queryMaximumCycleDetailReq=new QueryMaximumCycleDetailReq();
  queryMaximumCycleDetailReq.setCycleTypeCode("WEEKDAY");//CUSTOM_CONVENTION//sourceId:939998_1_41667
queryMaximumCycleDetailReq.setCycleTypeStandard("STANDARD");//sourceId:939999_1_41667
queryMaximumCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:939983_1_41667
if(reqDto!=null){
      queryMaximumCycleDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:939979_1_41667
queryMaximumCycleDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:939980_1_41667
    }

    /*3-4-04查询最大周期（标准工作日）[6664]   */
    Assert.isNull(queryMaximumCycleDetailReq.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-周期开始时间不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-周期结束时间不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq.getCycleTypeCode(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-周期类型标识不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq.getCycleTypeStandard(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-冗余周期类型标准化不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq.getSubjectLifeCycle(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（标准工作日）-主体生命周期不能为空",false);
      omsCycle_4 = mOmsCycleService.queryMaximumCycleDetail(queryMaximumCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-4-04查询最大周期（自定义工作日）  41668
      OmsCycle omsCycle_6 = null;
    QueryMaximumCycleDetailReq queryMaximumCycleDetailReq_1=new QueryMaximumCycleDetailReq();
  queryMaximumCycleDetailReq_1.setCycleTypeCode("CUSTOM_WEEKDAY");//CUSTOM_CONVENTION//sourceId:940038_1_41668
queryMaximumCycleDetailReq_1.setCycleTypeStandard("IRREGULAR");//sourceId:940037_1_41668
queryMaximumCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:940024_1_41668
queryMaximumCycleDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:940819_1_41668
if(reqDto!=null){
      queryMaximumCycleDetailReq_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:940020_1_41668
queryMaximumCycleDetailReq_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:940021_1_41668
    }

    /*3-4-04查询最大周期（自定义工作日）[6664]   */
    Assert.isNull(queryMaximumCycleDetailReq_1.getCycleStartTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-周期开始时间不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq_1.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-周期结束时间不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq_1.getCycleTypeCode(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-周期类型标识不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq_1.getCycleTypeStandard(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-冗余周期类型标准化不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq_1.getSubjectLifeCycle(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-主体生命周期不能为空",false);
Assert.isNull(queryMaximumCycleDetailReq_1.getSpaceId(),"D3-执行根据节假日分析父周期(公共)-3-4-04查询最大周期（自定义工作日）-创建于空间ID不能为空",false);
      omsCycle_6 = mOmsCycleService.queryMaximumCycleDetail(queryMaximumCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



if((omsCycle_6 == null )) {
        //if(3-4-04查询最大周期（自定义工作日）.出参 值等于空 )  41703

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    if(omsCycle_4 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(omsCycle_4!=null){
      receptionServiceReq_3.setCycleEndTime(omsCycle_4.getCycleEndTime());//SimpleFieldAssign//sourceId:940321_1_41704
    }

    /*约定出参：周期结束时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-约定出参：周期结束时间-周期结束时间不能为空",false);
      receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_4;
           }
      }
//virtualUsage D2检查时间范围查询(公共)  41670
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(omsCycle_4 !=null&&omsCycle_6 !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(omsCycle_4!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(omsCycle_4.getCycleEndTime());//SimpleFieldAssign//sourceId:939955_1_41670
    }
if(omsCycle_6!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(omsCycle_6.getCycleEndTime());//SimpleFieldAssign//sourceId:939957_1_41670
    }

    /*D2检查时间范围查询(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3-执行根据节假日分析父周期(公共)-D2检查时间范围查询(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE")||checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
        //if((D2标准工作日与自定义工作日最大比较.时间比较结果 等于 之前（小于） or D2标准工作日与自定义工作日最大比较.时间比较结果 等于 当前（等于）))  41671

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    if(omsCycle_6 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(omsCycle_6!=null){
      receptionServiceReq_4.setCycleEndTime(omsCycle_6.getCycleEndTime());//SimpleFieldAssign//sourceId:940321_1_41672
    }

    /*约定出参：周期结束时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-约定出参：周期结束时间-周期结束时间不能为空",false);
      receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_5 = receptionServiceRes_6;
           }
      }
else if((checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("LATER"))){
       //elseif(D2标准工作日与自定义工作日最大比较.时间比较结果 等于 之后（大于）)  41699

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
    if(omsCycle_4 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  if(omsCycle_4!=null){
      receptionServiceReq_5.setCycleEndTime(omsCycle_4.getCycleEndTime());//SimpleFieldAssign//sourceId:940321_1_41700
    }

    /*约定出参：周期结束时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getCycleEndTime(),"D3-执行根据节假日分析父周期(公共)-约定出参：周期结束时间-周期结束时间不能为空",false);
      receptionServiceRes_7 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_5);


      receptionServiceRes_5 = receptionServiceRes_7;
           }
      }
ImplementExecuteFatherCycleAnalysisByHolidayComRespDto retData = new ImplementExecuteFatherCycleAnalysisByHolidayComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCycleStartTime(receptionServiceRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:940323_1
    }
if(receptionServiceRes_5!=null){
      retData.setCycleEndTime(receptionServiceRes_5.getCycleEndTime());//SimpleFieldAssign//sourceId:940324_1
    }




return retData;
  }
/**
   * D3-分析当前周期类型是否末级周期类型(公共)[6887]
   * gen by moon at 5/21/2023, 6:37:20 AM
   */
  @Trace(operationName = "D3-分析当前周期类型是否末级周期类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalysisIsLastCycleTypeComRespDto implementAnalysisIsLastCycleTypeCom(ImplementAnalysisIsLastCycleTypeComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 =null;
//virtualUsage D2-执行字符串对比(公共)  42438
      ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:966818_1_42438
implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:966819_1_42438
    }

    /*D2-执行字符串对比(公共)[5774]   */

      implementStringEfficiencyCheckComRespDto = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 是)  42439

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:966788_1_42443

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-分析当前周期类型是否末级周期类型(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:967117_1_42444
    }

    /*约定出参：是否末级周期类型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-分析当前周期类型是否末级周期类型(公共)-约定出参：是否末级周期类型-是否不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))||(reqDto!= null&& reqDto.getLastCycleType() == null &&reqDto!= null&& reqDto.getCycleTypeCode() != null )){
       //elseif(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 否 or (D3-分析当前周期类型是否末级周期类型(公共).末级周期类型 值等于空  and D3-分析当前周期类型是否末级周期类型(公共).周期类型标识 值不等于空 ))  42445

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_2.setTureOrFalse("FALSE");//sourceId:966790_1_42446

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3-分析当前周期类型是否末级周期类型(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setTureOrFalse(receptionServiceRes_4.getTureOrFalse());//SimpleFieldAssign//sourceId:967117_1_42447
    }

    /*约定出参：是否末级周期类型[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTureOrFalse(),"D3-分析当前周期类型是否末级周期类型(公共)-约定出参：是否末级周期类型-是否不能为空",false);
      receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
ImplementAnalysisIsLastCycleTypeComRespDto retData = new ImplementAnalysisIsLastCycleTypeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTureOrFalse(receptionServiceRes_3.getTureOrFalse());//SimpleFieldAssign//sourceId:967127_1
    }




return retData;
  }
/**
   * D3获取目标内容计划工作时间[6867]
   * gen by moon at 4/28/2024, 2:57:01 PM
   */
  @Trace(operationName = "D3获取目标内容计划工作时间")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainTargetContPlanWorkTimeRespDto obtainTargetContPlanWorkTime(ObtainTargetContPlanWorkTimeReqDto reqDto){


      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
      ObtainTargetContIsOpenCustomReportComRespDto obtainTargetContIsOpenCustomReportComRespDto_1 =null;
AnalysisCutCycleReportTimeTypeCodeComRespDto analysisCutCycleReportTimeTypeCodeComRespDto_1 =null;
QueryCustomReportWorkCycleListComRespDto queryCustomReportWorkCycleListComRespDto_1 =null;
//virtualUsage D2查是否开启自定义汇报配置参数  51438
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_CUSTOM_REPORT");//CUSTOM_CONVENTION//sourceId:1221574_1_51438
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1221575_1_51438
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1221573_1_51438
    }

    /*D2查是否开启自定义汇报配置参数[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3获取目标内容计划工作时间-D2查是否开启自定义汇报配置参数-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3获取目标内容计划工作时间-D2查是否开启自定义汇报配置参数-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3获取目标内容计划工作时间-D2查是否开启自定义汇报配置参数-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
//virtualUsage D3获取目标内容是否开启自定义汇报(公共)  45086
      ObtainTargetContIsOpenCustomReportComRespDto obtainTargetContIsOpenCustomReportComRespDto = null;
    ObtainTargetContIsOpenCustomReportComReqDto obtainTargetContIsOpenCustomReportComReqDto=new ObtainTargetContIsOpenCustomReportComReqDto();
  if(reqDto!=null){
      obtainTargetContIsOpenCustomReportComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:981760_1_45086
obtainTargetContIsOpenCustomReportComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:981761_1_45086
obtainTargetContIsOpenCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981762_1_45086
    }

    /*D3获取目标内容是否开启自定义汇报(公共)[6949]   */
    Assert.isNull(obtainTargetContIsOpenCustomReportComReqDto.getEntityId(),"D3获取目标内容计划工作时间-D3获取目标内容是否开启自定义汇报(公共)-内容表主键ID不能为空",false);
Assert.isNull(obtainTargetContIsOpenCustomReportComReqDto.getTableTypeCode(),"D3获取目标内容计划工作时间-D3获取目标内容是否开启自定义汇报(公共)-内容表类型编码不能为空",false);
Assert.isNull(obtainTargetContIsOpenCustomReportComReqDto.getEvaluationTemplateId(),"D3获取目标内容计划工作时间-D3获取目标内容是否开启自定义汇报(公共)-冗余评价模板ID不能为空",false);
      obtainTargetContIsOpenCustomReportComRespDto = indexSystemService.obtainTargetContIsOpenCustomReportCom(obtainTargetContIsOpenCustomReportComReqDto)/*vcase invoke isSameApp*/;


      obtainTargetContIsOpenCustomReportComRespDto_1 = obtainTargetContIsOpenCustomReportComRespDto;
//virtualUsage 3-3-09查当前内容目标子周期类型  67632
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:961774_1_67632
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:961775_1_67632
queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:961777_1_67632
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:961779_1_67632
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:961776_1_67632
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:961778_1_67632
    }

    /*3-3-09查当前内容目标子周期类型[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(),"D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3获取目标内容计划工作时间-3-3-09查当前内容目标子周期类型-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D3分析裁剪子周期汇报时间类型(公共)  67631
AnalysisCutCycleReportTimeTypeCodeComRespDto analysisCutCycleReportTimeTypeCodeComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AnalysisCutCycleReportTimeTypeCodeComReqDto analysisCutCycleReportTimeTypeCodeComReqDto=new AnalysisCutCycleReportTimeTypeCodeComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      analysisCutCycleReportTimeTypeCodeComReqDto.setSubcycleType(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1760294_1_67631
    }

    /*D3分析裁剪子周期汇报时间类型(公共)[9456]   */
    Assert.isNull(analysisCutCycleReportTimeTypeCodeComReqDto.getSubcycleType(),"D3获取目标内容计划工作时间-D3分析裁剪子周期汇报时间类型(公共)-子周期周期类型不能为空",false);
      analysisCutCycleReportTimeTypeCodeComRespDto = analysisCutCycleReportTimeTypeCodeCom(analysisCutCycleReportTimeTypeCodeComReqDto)/*vcase invoke 同服务,同domain*/;


      analysisCutCycleReportTimeTypeCodeComRespDto_1 = analysisCutCycleReportTimeTypeCodeComRespDto;
           }
//virtualUsage D3查询自定义汇报工作周期列表(公共)  67637
      QueryCustomReportWorkCycleListComRespDto queryCustomReportWorkCycleListComRespDto = null;
    QueryCustomReportWorkCycleListComReqDto queryCustomReportWorkCycleListComReqDto=new QueryCustomReportWorkCycleListComReqDto();
  queryCustomReportWorkCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1761552_1_67637
queryCustomReportWorkCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1761553_1_67637
if(reqDto!=null){
      queryCustomReportWorkCycleListComReqDto.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1761551_1_67637
queryCustomReportWorkCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761550_1_67637
    }

    /*D3查询自定义汇报工作周期列表(公共)[9458]   */
    Assert.isNull(queryCustomReportWorkCycleListComReqDto.getEvaObjEntityId(),"D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryCustomReportWorkCycleListComReqDto.getEvaObjTypeCode(),"D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryCustomReportWorkCycleListComReqDto.getTargetCycleContentId(),"D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryCustomReportWorkCycleListComReqDto.getEvaluationTemplateId(),"D3获取目标内容计划工作时间-D3查询自定义汇报工作周期列表(公共)-冗余评价模板ID不能为空",false);
      queryCustomReportWorkCycleListComRespDto = queryCustomReportWorkCycleListCom(queryCustomReportWorkCycleListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryCustomReportWorkCycleListComRespDto_1 = queryCustomReportWorkCycleListComRespDto;
ObtainTargetContPlanWorkTimeRespDto retData = new ObtainTargetContPlanWorkTimeRespDto();
  if(queryCustomReportWorkCycleListComRespDto_1!=null){
      retData.setTargetContPlanWorkTimeList(queryCustomReportWorkCycleListComRespDto_1.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1761557_1
retData.setTargetCycleParentCycleId(queryCustomReportWorkCycleListComRespDto_1.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1761558_1
retData.setTargetCycleMidCycleId(queryCustomReportWorkCycleListComRespDto_1.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1761559_1
    }
if(analysisCutCycleReportTimeTypeCodeComRespDto_1!=null){
      retData.setCutCycleReportTimeTypeCode(analysisCutCycleReportTimeTypeCodeComRespDto_1.getCutCycleReportTimeTypeCode());//SimpleFieldAssign//sourceId:1760636_1
    }
if(obtainTargetContIsOpenCustomReportComRespDto_1!=null){
      retData.setIsOpenCustomReport(obtainTargetContIsOpenCustomReportComRespDto_1.getIsOpenCustomReport());//SimpleFieldAssign//sourceId:981764_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setTempIsOpenCustomReport(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:1221577_1
    }




return retData;
  }
/**
   * D3设置目标内容成果汇报时间(公共)[6868]
   * gen by moon at 4/28/2024, 2:33:01 PM
   */
  @Trace(operationName = "D3设置目标内容成果汇报时间(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public SetTargetContActualWorkTimeComRespDto setTargetContActualWorkTimeCom(SetTargetContActualWorkTimeComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
      ImplementWriteBackTargetContCustomReportComRespDto implementWriteBackTargetContCustomReportComRespDto_1 =null;
//virtualUsage 3-3-09查目标父周期  42937
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:963302_1_42937
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:963300_1_42937
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:963301_1_42937
    }

    /*3-3-09查目标父周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3设置目标内容成果汇报时间(公共)-3-3-09查目标父周期-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3设置目标内容成果汇报时间(公共)-3-3-09查目标父周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3设置目标内容成果汇报时间(公共)-3-3-09查目标父周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
if((reqDto!= null&&  reqDto.getTargetCyclePsetList() !=null && reqDto.getTargetCyclePsetList().size()>0)) {
        //if(D3设置目标内容成果汇报时间(公共).目标周期规划设置列表数据集条数 大于 0)  42320

boolean bOOLEAN ;
    List<OmsTargetCyclePlanSet> listOmsTargetCyclePlanSet=new ArrayList<>();
  if(reqDto!= null&&  reqDto.getTargetCyclePsetList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetCyclePsetList())){
      listOmsTargetCyclePlanSet = //objList-to-objLists
        reqDto.getTargetCyclePsetList().stream().map(item -> {
      OmsTargetCyclePlanSet elm = new OmsTargetCyclePlanSet();
      if(item!=null){
      elm.setTargetCyclePlanSetId(item.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:205265_2_42321
elm.setTargetActualStartTime(item.getTargetActualStartTime());//SimpleFieldAssign//sourceId:205266_2_42321
elm.setTargetActualEndtTime(item.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:205267_2_42321
elm.setAcceptancePlanTime(item.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:205769_2_42321
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:963788_1_42321
    }

    /*3-3-08批量改目标子周期规划设置[3596]   */

      bOOLEAN = mOmsTargetCyclePlanSetService.batchUpdateTargetCyclePset(listOmsTargetCyclePlanSet)/*vcase invoke 本地 method 方法调用;*/;



ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto = null;
    ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto=new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
if(reqDto!=null){
      implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1760648_1_67633
implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760647_1_67633
    }

    /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
    Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaObjTargetCycleId(),"D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaluationTemplateId(),"D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteTargetContFatherOrMidReportTimeComRespDto = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto)/*vcase invoke 同服务,同domain*/;



if((reqDto!= null&& reqDto.getTargetCycleMidCycleId() != null )) {
        //if(D3设置目标内容成果汇报时间(公共).目标周期中期ID 值不等于空 )  67634

ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = null;
    ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1=new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
if(reqDto!=null){
      implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1760648_1_67635
implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760647_1_67635
    }

    /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
    Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaObjTargetCycleId(),"D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaluationTemplateId(),"D3设置目标内容成果汇报时间(公共)-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1)/*vcase invoke 同服务,同domain*/;



    }
      ImplementWriteBackTargetContCustomReportComRespDto implementWriteBackTargetContCustomReportComRespDto = null;
    ImplementWriteBackTargetContCustomReportComReqDto implementWriteBackTargetContCustomReportComReqDto=new ImplementWriteBackTargetContCustomReportComReqDto();
  if(reqDto!=null){
      implementWriteBackTargetContCustomReportComReqDto.setTargetCycleParentCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:968645_1_67636
implementWriteBackTargetContCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:968644_1_67636
    }

    /*D3执行回写目标内容自定义汇报(公共)[6892]   */
    Assert.isNull(implementWriteBackTargetContCustomReportComReqDto.getTargetCycleParentCycleId(),"D3设置目标内容成果汇报时间(公共)-D3执行回写目标内容自定义汇报(公共)-目标周期父周期ID不能为空",false);
Assert.isNull(implementWriteBackTargetContCustomReportComReqDto.getEvaluationTemplateId(),"D3设置目标内容成果汇报时间(公共)-D3执行回写目标内容自定义汇报(公共)-冗余评价模板ID不能为空",false);
      implementWriteBackTargetContCustomReportComRespDto = targetCycleService.implementWriteBackTargetContCustomReportCom(implementWriteBackTargetContCustomReportComReqDto)/*vcase invoke isSameApp*/;


      implementWriteBackTargetContCustomReportComRespDto_1 = implementWriteBackTargetContCustomReportComRespDto;
      }
SetTargetContActualWorkTimeComRespDto retData = new SetTargetContActualWorkTimeComRespDto();
  if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setCyclelAlias(omsEvaluationObjectTargetCycle_1.getCyclelAlias());//SimpleFieldAssign//sourceId:1151091_1
      retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:980550_1
retData.setTargetCycleContentTypeCode(omsEvaluationObjectTargetCycle_1.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:980553_1
retData.setTargetId(omsEvaluationObjectTargetCycle_1.getTargetId());//SimpleFieldAssign//sourceId:980554_1
    }
  if(implementWriteBackTargetContCustomReportComRespDto_1!=null){
      retData.setIsOpenCustomReport(implementWriteBackTargetContCustomReportComRespDto_1.getIsOpenCustomReport());//SimpleFieldAssign//sourceId:971155_1
    }




return retData;
  }
/**
   * D3-新增标准执行周期阶段(公共)[6870]
   * gen by moon at 7/6/2024, 11:56:48 PM
   */
  @Trace(operationName = "D3-新增标准执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddStandardExecuteCycleStageComComRespDto addStandardExecuteCycleStageComCom(AddStandardExecuteCycleStageComComReqDto reqDto){


      ImplementSpecProcessCycleIsOpenComRespDto implementSpecProcessCycleIsOpenComRespDto_1 =null;
      //virtualUsage D3-查周期类型相关配置(公共)  42957
      ImplementSpecProcessCycleIsOpenComRespDto implementSpecProcessCycleIsOpenComRespDto = null;
          ImplementSpecProcessCycleIsOpenComReqDto implementSpecProcessCycleIsOpenComReqDto=new ImplementSpecProcessCycleIsOpenComReqDto();
  if(reqDto!=null){
      implementSpecProcessCycleIsOpenComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:984050_1_42957
implementSpecProcessCycleIsOpenComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984051_1_42957
    }

    /*D3-查周期类型相关配置(公共)[6948]   */
    Assert.isNull(implementSpecProcessCycleIsOpenComReqDto.getTargetCycleContentTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-查周期类型相关配置(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementSpecProcessCycleIsOpenComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-查周期类型相关配置(公共)-冗余评价模板ID不能为空",false);
      implementSpecProcessCycleIsOpenComRespDto = implementSpecProcessCycleIsOpenCom(implementSpecProcessCycleIsOpenComReqDto)/*vcase invoke 同服务,同domain*/;


      implementSpecProcessCycleIsOpenComRespDto_1 = implementSpecProcessCycleIsOpenComRespDto;
if((implementSpecProcessCycleIsOpenComRespDto!= null&&  implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList() !=null && implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList().size()>0)) {
        //if(D3-查周期类型相关配置(公共).模版启用的周期类型列表数据集条数 大于 0)  42943

      AddSubCycleExecuteCycleStageComRespDto addSubCycleExecuteCycleStageComRespDto = null;
    if(implementSpecProcessCycleIsOpenComRespDto !=null){
    AddSubCycleExecuteCycleStageComReqDto addSubCycleExecuteCycleStageComReqDto=new AddSubCycleExecuteCycleStageComReqDto();
  if(implementSpecProcessCycleIsOpenComRespDto!= null&&  implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList() !=null&& !CollectionUtil.isEmpty(implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList())){
      addSubCycleExecuteCycleStageComReqDto.setTemplateOpenCycleTypeList(implementSpecProcessCycleIsOpenComRespDto.getTemplateOpenCycleTypeList().stream().map(item -> BeanUtil.toBean(item, TemplateOpenCycleTypeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:984063_1_42944
    }
  if(reqDto!=null){
      addSubCycleExecuteCycleStageComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:972465_1_42944
addSubCycleExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:980886_1_42944
addSubCycleExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:980887_1_42944
addSubCycleExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:962632_1_42944
    }
if(implementSpecProcessCycleIsOpenComRespDto!=null){
      addSubCycleExecuteCycleStageComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:962633_1_42944
addSubCycleExecuteCycleStageComReqDto.setSubcycleType(implementSpecProcessCycleIsOpenComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:987351_1_42944
addSubCycleExecuteCycleStageComReqDto.setSortCreateTime(implementSpecProcessCycleIsOpenComRespDto.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:977188_1_42944
addSubCycleExecuteCycleStageComReqDto.setCycleTypeCode(implementSpecProcessCycleIsOpenComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1816323_1_42944
    }

    /*D3-3新增过程执行周期阶段(公共)[5522]   */
    Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getIsDefinedExecuteCycleStage(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getTargetCycleContentId(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getTargetId(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-冗余目标ID不能为空",false);
Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getSubcycleType(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-子周期周期类型不能为空",false);
Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addSubCycleExecuteCycleStageComReqDto.getSortCreateTime(),"D3-新增标准执行周期阶段(公共)-D3-3新增过程执行周期阶段(公共)-评价模板创建时间排序不能为空",false);
      addSubCycleExecuteCycleStageComRespDto = targetCycleService.addSubCycleExecuteCycleStageCom(addSubCycleExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;



           }
if((implementSpecProcessCycleIsOpenComRespDto!= null&&  implementSpecProcessCycleIsOpenComRespDto.getTureOrFalse() !=null && implementSpecProcessCycleIsOpenComRespDto.getTureOrFalse().equals("TRUE"))) {
        //if(D3-查周期类型相关配置(公共).是否启用双周周期类型 等于 是)  68983

ImplementDoubleWeekExecuteCycleComRespDto implementDoubleWeekExecuteCycleComRespDto = null;
    if(implementSpecProcessCycleIsOpenComRespDto !=null){
          ImplementDoubleWeekExecuteCycleComReqDto implementDoubleWeekExecuteCycleComReqDto=new ImplementDoubleWeekExecuteCycleComReqDto();
  if(implementSpecProcessCycleIsOpenComRespDto!=null){
      implementDoubleWeekExecuteCycleComReqDto.setCycleTypeCode(implementSpecProcessCycleIsOpenComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1816290_1_68984
implementDoubleWeekExecuteCycleComReqDto.setIsLastCycle(implementSpecProcessCycleIsOpenComRespDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1816291_1_68984
implementDoubleWeekExecuteCycleComReqDto.setNextCyclePeriod(implementSpecProcessCycleIsOpenComRespDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1816292_1_68984
implementDoubleWeekExecuteCycleComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1816296_1_68984
implementDoubleWeekExecuteCycleComReqDto.setSortCreateTime(implementSpecProcessCycleIsOpenComRespDto.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1816298_1_68984
    }
if(reqDto!=null){
      implementDoubleWeekExecuteCycleComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1816297_1_68984
implementDoubleWeekExecuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1816295_1_68984
implementDoubleWeekExecuteCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1816294_1_68984
implementDoubleWeekExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1816293_1_68984
    }

    /*D3-执行双周执行周期处理(公共)[6985]   */
    Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getCycleTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-双周周期类型标识不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getIsLastCycle(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-双周是否末级周期不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getIsDefinedExecuteCycleStage(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getTargetCycleContentId(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getTargetCycleContentTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getTargetId(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementDoubleWeekExecuteCycleComReqDto.getSortCreateTime(),"D3-新增标准执行周期阶段(公共)-D3-执行双周执行周期处理(公共)-评价模板创建时间排序不能为空",false);
      implementDoubleWeekExecuteCycleComRespDto = implementDoubleWeekExecuteCycleCom(implementDoubleWeekExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }
           }
if((reqDto!= null&&  reqDto.getIsDefinedExecuteCycleStage() !=null && reqDto.getIsDefinedExecuteCycleStage().equals("TRUE")||implementSpecProcessCycleIsOpenComRespDto!= null&&  implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType() !=null && implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType().equals("TRUE"))) {
        //if((D3-新增标准执行周期阶段(公共).是否自定义执行周期阶段 等于 是 or D3-查周期类型相关配置(公共).是否开启过程特殊周期 等于 是))  42959

      ImplementCompStdExecuteCycleStageComRespDto implementCompStdExecuteCycleStageComRespDto = null;
    if(implementSpecProcessCycleIsOpenComRespDto !=null){
    ImplementCompStdExecuteCycleStageComReqDto implementCompStdExecuteCycleStageComReqDto=new ImplementCompStdExecuteCycleStageComReqDto();
  if(implementSpecProcessCycleIsOpenComRespDto!=null){
      implementCompStdExecuteCycleStageComReqDto.setCycleTypeList(implementSpecProcessCycleIsOpenComRespDto.getCourseCycleTypeList());//list-field-assign//sourceId:981125_1_42961
implementCompStdExecuteCycleStageComReqDto.setLastCycleType(implementSpecProcessCycleIsOpenComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:984074_1_42961
implementCompStdExecuteCycleStageComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:967149_1_42961
    }
  if(reqDto!=null){
      implementCompStdExecuteCycleStageComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:981752_1_42961
implementCompStdExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:981088_1_42961
implementCompStdExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:981089_1_42961
implementCompStdExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:967150_1_42961
    }

    /*D3-执行补偿新增标准过程执行周期(公共)[6873]   */
    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getIsDefinedExecuteCycleStage(),"D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getTargetCycleContentId(),"D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-关联目标内容类型编码不能为空",false);
    Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getTargetId(),"D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementCompStdExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-执行补偿新增标准过程执行周期(公共)-冗余评价模板ID不能为空",false);
      implementCompStdExecuteCycleStageComRespDto = implementCompStdExecuteCycleStageCom(implementCompStdExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
      }
//virtualUsage D3-3新增工作周期执行周期阶段(公共)  42313
      AddMetaPhaseExecuteCycleStageComRespDto addMetaPhaseExecuteCycleStageComRespDto = null;
    if(implementSpecProcessCycleIsOpenComRespDto !=null){
          AddMetaPhaseExecuteCycleStageComReqDto addMetaPhaseExecuteCycleStageComReqDto=new AddMetaPhaseExecuteCycleStageComReqDto();
  if(reqDto!=null){
addMetaPhaseExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:980876_1_42313
addMetaPhaseExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:980877_1_42313
addMetaPhaseExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:982217_1_42313
addMetaPhaseExecuteCycleStageComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:972468_1_42313
    }
if(implementSpecProcessCycleIsOpenComRespDto!=null){
      addMetaPhaseExecuteCycleStageComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:962636_1_42313
    }

    /*D3-3新增工作周期执行周期阶段(公共)[5518]   */
Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getTargetCycleContentId(),"D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getTargetId(),"D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-冗余目标ID不能为空",false);
Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addMetaPhaseExecuteCycleStageComReqDto.getIsDefinedExecuteCycleStage(),"D3-新增标准执行周期阶段(公共)-D3-3新增工作周期执行周期阶段(公共)-是否自定义执行周期阶段不能为空",false);
      addMetaPhaseExecuteCycleStageComRespDto = targetCycleService.addMetaPhaseExecuteCycleStageCom(addMetaPhaseExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3-3修改当前及下一个执行周期阶段(公共)  42314
      ImplementAnalyzeCompExecuteCycleStageComRespDto implementAnalyzeCompExecuteCycleStageComRespDto = null;
    if(implementSpecProcessCycleIsOpenComRespDto !=null){
    ImplementAnalyzeCompExecuteCycleStageComReqDto implementAnalyzeCompExecuteCycleStageComReqDto=new ImplementAnalyzeCompExecuteCycleStageComReqDto();
  if(implementSpecProcessCycleIsOpenComRespDto!=null){
      implementAnalyzeCompExecuteCycleStageComReqDto.setSubcycleType(implementSpecProcessCycleIsOpenComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:980292_1_42314
    }
  if(reqDto!=null){
      implementAnalyzeCompExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:980291_1_42314
    }

    /*D3-3修改当前及下一个执行周期阶段(公共)[5461]   */
    Assert.isNull(implementAnalyzeCompExecuteCycleStageComReqDto.getSubcycleType(),"D3-新增标准执行周期阶段(公共)-D3-3修改当前及下一个执行周期阶段(公共)-子周期周期类型不能为空",false);
Assert.isNull(implementAnalyzeCompExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-3修改当前及下一个执行周期阶段(公共)-冗余评价模板ID不能为空",false);
      implementAnalyzeCompExecuteCycleStageComRespDto = targetCycleService.implementAnalyzeCompExecuteCycleStageCom(implementAnalyzeCompExecuteCycleStageComReqDto)/*vcase invoke isSameApp*/;



           }
if((implementSpecProcessCycleIsOpenComRespDto!= null&&  implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType() !=null && implementSpecProcessCycleIsOpenComRespDto.getIsOpenSpecCycleType().equals("TRUE"))) {
        //if(D3-查周期类型相关配置(公共).是否开启过程特殊周期 等于 是)  43063

      RefreshSpecCycleNameComRespDto refreshSpecCycleNameComRespDto = null;
    if(implementSpecProcessCycleIsOpenComRespDto !=null){
    RefreshSpecCycleNameComReqDto refreshSpecCycleNameComReqDto=new RefreshSpecCycleNameComReqDto();
  if(reqDto!=null){
      refreshSpecCycleNameComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:983581_1_43064
refreshSpecCycleNameComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:983582_1_43064
refreshSpecCycleNameComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:962648_1_43064
    }
if(implementSpecProcessCycleIsOpenComRespDto!=null){
      refreshSpecCycleNameComReqDto.setTargetId(implementSpecProcessCycleIsOpenComRespDto.getTargetId());//SimpleFieldAssign//sourceId:962649_1_43064
refreshSpecCycleNameComReqDto.setCustomField(implementSpecProcessCycleIsOpenComRespDto.getTempOpenSpecialCycleType());//SimpleFieldAssign//sourceId:984077_1_43064
    }

    /*D3-更新特殊周期周期名称(公共)[4989]   */
    Assert.isNull(refreshSpecCycleNameComReqDto.getTargetCycleContentId(),"D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-关联目标内容ID不能为空",false);
Assert.isNull(refreshSpecCycleNameComReqDto.getTargetCycleContentTypeCode(),"D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(refreshSpecCycleNameComReqDto.getTargetId(),"D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-冗余目标ID不能为空",false);
Assert.isNull(refreshSpecCycleNameComReqDto.getEvaluationTemplateId(),"D3-新增标准执行周期阶段(公共)-D3-更新特殊周期周期名称(公共)-冗余评价模板ID不能为空",false);
      refreshSpecCycleNameComRespDto = targetCycleService.refreshSpecCycleNameCom(refreshSpecCycleNameComReqDto)/*vcase invoke isSameApp*/;



           }
           }
AddStandardExecuteCycleStageComComRespDto retData = new AddStandardExecuteCycleStageComComRespDto();
  if(implementSpecProcessCycleIsOpenComRespDto_1!=null){
      retData.setPeriodicModeTypeCode(implementSpecProcessCycleIsOpenComRespDto_1.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1655002_1
retData.setSubcycleType(implementSpecProcessCycleIsOpenComRespDto_1.getSubcycleType());//SimpleFieldAssign//sourceId:1922991_1
retData.setLastCycleType(implementSpecProcessCycleIsOpenComRespDto_1.getLastCycleType());//SimpleFieldAssign//sourceId:1654654_1
retData.setSecondLastCycleType(implementSpecProcessCycleIsOpenComRespDto_1.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1655003_1
    }




return retData;
  }
/**
   * D3-执行补偿新增标准过程执行周期(公共)[6873]
   * gen by moon at 6/3/2024, 4:38:00 PM
   */
  @Trace(operationName = "D3-执行补偿新增标准过程执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCompStdExecuteCycleStageComRespDto implementCompStdExecuteCycleStageCom(ImplementCompStdExecuteCycleStageComReqDto reqDto){


      //virtualUsage D3-3-查目标周期列表（用于发牌）  42357
      QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
    QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto=new QueryEvaObjTargetCycleListComReqDto();
  queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964498_1_42357
queryEvaObjTargetCycleListComReqDto.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:964499_1_42357
queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:964500_1_42357
queryEvaObjTargetCycleListComReqDto.setTreeTypeCode("PLAN_TREE");//sourceId:964501_1_42357
queryEvaObjTargetCycleListComReqDto.setIsSubCycle("TRUE");//sourceId:964504_1_42357
queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:964505_1_42357
if(reqDto!=null){
      queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:964503_1_42357
queryEvaObjTargetCycleListComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:964502_1_42357
    }

    /*D3-3-查目标周期列表（用于发牌）[3451]   */
    Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(),"D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(),"D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsSubCycle(),"D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(),"D3-执行补偿新增标准过程执行周期(公共)-D3-3-查目标周期列表（用于发牌）-是否存档不能为空",false);
      queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



if((queryEvaObjTargetCycleListComRespDto!= null&&  queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3-3-查目标周期列表（用于发牌）.被评对象目标周期列表数据集条数 大于 0)  42358

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()){

//ModelCode: circulationCollections
        for (String circulationCollectionsRes_2: reqDto.getCycleTypeList()){

JudgeCycleTypeIsPlatformComRespDto judgeCycleTypeIsPlatformComRespDto = null;
    JudgeCycleTypeIsPlatformComReqDto judgeCycleTypeIsPlatformComReqDto=new JudgeCycleTypeIsPlatformComReqDto();
  if(circulationCollectionsRes_2!=null){
      judgeCycleTypeIsPlatformComReqDto.setEndValue(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:966106_1_42989
    }

    /*D3判断周期类型是否平台(公共)[4972]   */
    Assert.isNull(judgeCycleTypeIsPlatformComReqDto.getEndValue(),"D3-执行补偿新增标准过程执行周期(公共)-D3判断周期类型是否平台(公共)-周期类型值不能为空",false);
      judgeCycleTypeIsPlatformComRespDto = targetCycleService.judgeCycleTypeIsPlatformCom(judgeCycleTypeIsPlatformComReqDto)/*vcase invoke isSameApp*/;



ImplementFindExecuteCycleByActualWorkTimeComRespDto implementFindExecuteCycleByActualWorkTimeComRespDto = null;
    if(judgeCycleTypeIsPlatformComRespDto !=null){
          ImplementFindExecuteCycleByActualWorkTimeComReqDto implementFindExecuteCycleByActualWorkTimeComReqDto=new ImplementFindExecuteCycleByActualWorkTimeComReqDto();
  if(circulationCollectionsRes!=null){
      implementFindExecuteCycleByActualWorkTimeComReqDto.setTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:966054_1_42990
    }
if(circulationCollectionsRes_2!=null){
      implementFindExecuteCycleByActualWorkTimeComReqDto.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:966051_1_42990
    }
if(judgeCycleTypeIsPlatformComRespDto!=null){
      implementFindExecuteCycleByActualWorkTimeComReqDto.setPlatformData(judgeCycleTypeIsPlatformComRespDto.getPlatformData());//SimpleFieldAssign//sourceId:966052_1_42990
implementFindExecuteCycleByActualWorkTimeComReqDto.setSpaceId(judgeCycleTypeIsPlatformComRespDto.getSpaceId());//SimpleFieldAssign//sourceId:966053_1_42990
    }

    /*D3-根据目标周期实际开始结束时间找周期(公共)[6885]   */

      implementFindExecuteCycleByActualWorkTimeComRespDto = implementFindExecuteCycleByActualWorkTimeCom(implementFindExecuteCycleByActualWorkTimeComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((implementFindExecuteCycleByActualWorkTimeComRespDto!= null&& implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId() != null &&!(circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2 !=null && circulationCollectionsRes_2.equals("DOUBLE_WEEKS")))) {
        //if((D3-用目标周期实际开始时间找子周期头部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际开始时间）.答案值 不等于 双周))  42991

ImplementTargetContentNextCyclePeriodComRespDto implementTargetContentNextCyclePeriodComRespDto = null;
    ImplementTargetContentNextCyclePeriodComReqDto implementTargetContentNextCyclePeriodComReqDto=new ImplementTargetContentNextCyclePeriodComReqDto();
  if(circulationCollectionsRes_2!=null){
      implementTargetContentNextCyclePeriodComReqDto.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:984665_1_43122
    }
if(reqDto!=null){
      implementTargetContentNextCyclePeriodComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:984663_1_43122
implementTargetContentNextCyclePeriodComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984664_1_43122
    }

    /*D3-查询目标内容可循环周期类型(公共)[6954]   */
    Assert.isNull(implementTargetContentNextCyclePeriodComReqDto.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-周期类型标识不能为空",false);
Assert.isNull(implementTargetContentNextCyclePeriodComReqDto.getTargetCycleContentTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementTargetContentNextCyclePeriodComReqDto.getEvaluationTemplateId(),"D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-冗余评价模板ID不能为空",false);
      implementTargetContentNextCyclePeriodComRespDto = implementTargetContentNextCyclePeriodCom(implementTargetContentNextCyclePeriodComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementAnalysisIsLastCycleTypeComRespDto implementAnalysisIsLastCycleTypeComRespDto = null;
          ImplementAnalysisIsLastCycleTypeComReqDto implementAnalysisIsLastCycleTypeComReqDto=new ImplementAnalysisIsLastCycleTypeComReqDto();
  if(reqDto!=null){
      implementAnalysisIsLastCycleTypeComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:967134_1_42994
    }
if(circulationCollectionsRes_2!=null){
      implementAnalysisIsLastCycleTypeComReqDto.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:967135_1_42994
    }

    /*D3-分析当前周期类型是否末级周期类型(公共)[6887]   */
    Assert.isNull(implementAnalysisIsLastCycleTypeComReqDto.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-分析当前周期类型是否末级周期类型(公共)-周期类型标识不能为空",false);
      implementAnalysisIsLastCycleTypeComRespDto = implementAnalysisIsLastCycleTypeCom(implementAnalysisIsLastCycleTypeComReqDto)/*vcase invoke 同服务,同domain*/;



GenerateOrderNumberComRespDto generateOrderNumberComRespDto = null;
    if(implementFindExecuteCycleByActualWorkTimeComRespDto !=null){
          GenerateOrderNumberComReqDto generateOrderNumberComReqDto=new GenerateOrderNumberComReqDto();
  if(circulationCollectionsRes!=null){
      generateOrderNumberComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:982092_1_43030
    }
if(implementFindExecuteCycleByActualWorkTimeComRespDto!=null){
      generateOrderNumberComReqDto.setCycleEndTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:982093_1_43030
    }

    /*D3生成周期排序服务(公共)[3545]   */
    Assert.isNull(generateOrderNumberComReqDto.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空",false);
Assert.isNull(generateOrderNumberComReqDto.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空",false);
      generateOrderNumberComRespDto = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto)/*vcase invoke isSameApp*/;



           }
String string = null;
    if(implementFindExecuteCycleByActualWorkTimeComRespDto !=null&&implementTargetContentNextCyclePeriodComRespDto !=null&&implementAnalysisIsLastCycleTypeComRespDto !=null&&generateOrderNumberComRespDto !=null){
          OmsExecuteCycleStage omsExecuteCycleStage=new OmsExecuteCycleStage();
  omsExecuteCycleStage.setIsFatherCycle("FALSE");//sourceId:966117_1_42995
omsExecuteCycleStage.setIsSubCycle("FALSE");//sourceId:966118_1_42995
omsExecuteCycleStage.setIsMetaphase("FALSE");//sourceId:966119_1_42995
omsExecuteCycleStage.setIsProcessCycleStage("TRUE");//sourceId:966120_1_42995
omsExecuteCycleStage.setIsStartCycle("FALSE");//sourceId:966125_1_42995
omsExecuteCycleStage.setIsEndCycle("FALSE");//sourceId:966126_1_42995
omsExecuteCycleStage.setIsCurrentCycle("FALSE");//sourceId:966140_1_42995
omsExecuteCycleStage.setIsNextCycle("FALSE");//sourceId:966141_1_42995
if(circulationCollectionsRes!=null){
      omsExecuteCycleStage.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:966142_1_42995
omsExecuteCycleStage.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:966136_1_42995
omsExecuteCycleStage.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:966130_1_42995
omsExecuteCycleStage.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:991117_1_42995
omsExecuteCycleStage.setEvaTempCreateTime(circulationCollectionsRes.getSortCreateTime());//SimpleFieldAssign//sourceId:966115_1_42995
    }
if(implementFindExecuteCycleByActualWorkTimeComRespDto!=null){
      omsExecuteCycleStage.setCycleId(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId());//SimpleFieldAssign//sourceId:966114_1_42995
omsExecuteCycleStage.setCycleStandardName(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleStandardName());//SimpleFieldAssign//sourceId:966135_1_42995
omsExecuteCycleStage.setCycleEndTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:966137_1_42995
omsExecuteCycleStage.setFillEndtTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:966131_1_42995
omsExecuteCycleStage.setEvaluateEndtTime(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:991118_1_42995
omsExecuteCycleStage.setCycleTypeCode(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:966138_1_42995
omsExecuteCycleStage.setCycleTypeInstanceCode(implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1605080_1_42995
    }
if(implementTargetContentNextCyclePeriodComRespDto!=null){
      omsExecuteCycleStage.setNextCyclePeriod(implementTargetContentNextCyclePeriodComRespDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:967576_1_42995
    }
if(implementAnalysisIsLastCycleTypeComRespDto!=null){
      omsExecuteCycleStage.setIsLastCycle(implementAnalysisIsLastCycleTypeComRespDto.getTureOrFalse());//SimpleFieldAssign//sourceId:966127_1_42995
    }
if(generateOrderNumberComRespDto!=null){
      omsExecuteCycleStage.setOrderNumber(generateOrderNumberComRespDto.getOrderNumber());//SimpleFieldAssign//sourceId:966116_1_42995
    }
if(reqDto!=null){
      omsExecuteCycleStage.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:966121_1_42995
omsExecuteCycleStage.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:966123_1_42995
omsExecuteCycleStage.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:966122_1_42995
omsExecuteCycleStage.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:966129_1_42995
omsExecuteCycleStage.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:966124_1_42995
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage.getEvaObjTargetCycleId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getCycleId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getCycleStandardName(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage.getFillStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage.getFillEndtTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsLastCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage.getOrderNumber(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期排序不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsFatherCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsSubCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsMetaphase(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsProcessCycleStage(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsDefinedExecuteCycleStage(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage.getRelateContentId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getRelateContentTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage.getTargetId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getEvaluationTemplateId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsStartCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsEndCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage.getEvaTempCreateTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
      string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((implementFindExecuteCycleByActualWorkTimeComRespDto!= null&& implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId() != null &&circulationCollectionsRes_2!= null&&  circulationCollectionsRes_2 !=null && circulationCollectionsRes_2.equals("DOUBLE_WEEKS"))){
       //elseif((D3-用目标周期实际开始时间找子周期头部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际开始时间）.答案值 等于 双周))  43056

OmsExecuteCycleStage omsExecuteCycleStage_1 = null;
    QueryExecuteCycleLessStartBigEqualEndDetailReq queryExecuteCycleLessStartBigEqualEndDetailReq=new QueryExecuteCycleLessStartBigEqualEndDetailReq();
  queryExecuteCycleLessStartBigEqualEndDetailReq.setIsProcessCycleStage("TRUE");//sourceId:1816386_1_68995
queryExecuteCycleLessStartBigEqualEndDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1816389_1_68995
if(circulationCollectionsRes!=null){
      queryExecuteCycleLessStartBigEqualEndDetailReq.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816383_1_68995
queryExecuteCycleLessStartBigEqualEndDetailReq.setCycleEndTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816384_1_68995
    }
if(circulationCollectionsRes_2!=null){
      queryExecuteCycleLessStartBigEqualEndDetailReq.setCycleTypeCode(circulationCollectionsRes_2);//SimpleFieldAssign//sourceId:1816385_1_68995
    }
if(reqDto!=null){
      queryExecuteCycleLessStartBigEqualEndDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1816387_1_68995
queryExecuteCycleLessStartBigEqualEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1816388_1_68995
    }

    /*3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）[9657]   */
    Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getIsProcessCycleStage(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getRelateContentId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getEvaluationTemplateId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleLessStartBigEqualEndDetailReq.getSubjectLifeCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期开始时间所在执行周期详情（用于裁剪开始时间）-主体生命周期不能为空",false);
      omsExecuteCycleStage_1 = mOmsExecuteCycleStageService.queryExecuteCycleLessStartBigEqualEndDetail(queryExecuteCycleLessStartBigEqualEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsExecuteCycleStage_1== null||  omsExecuteCycleStage_1.getExecuteCycleStageId() ==null,"找不到数据，系统异常",false);


GenerateOrderNumberComRespDto generateOrderNumberComRespDto_2 = null;
    if(omsExecuteCycleStage_1 !=null){
          GenerateOrderNumberComReqDto generateOrderNumberComReqDto_1=new GenerateOrderNumberComReqDto();
  if(circulationCollectionsRes!=null){
      generateOrderNumberComReqDto_1.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:982092_1_69552
    }
if(omsExecuteCycleStage_1!=null){
      generateOrderNumberComReqDto_1.setCycleEndTime(omsExecuteCycleStage_1.getCycleEndTime());//SimpleFieldAssign//sourceId:982093_1_69552
    }

    /*D3生成周期排序服务(公共)[3545]   */
    Assert.isNull(generateOrderNumberComReqDto_1.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空",false);
Assert.isNull(generateOrderNumberComReqDto_1.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空",false);
      generateOrderNumberComRespDto_2 = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto_1)/*vcase invoke isSameApp*/;



           }
boolean bOOLEAN ;
    if(omsExecuteCycleStage_1 !=null&&generateOrderNumberComRespDto_2 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_3=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage_1!=null){
      omsExecuteCycleStage_3.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1816391_1_68996
    }
if(circulationCollectionsRes!=null){
      omsExecuteCycleStage_3.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816393_1_68996
omsExecuteCycleStage_3.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816394_1_68996
omsExecuteCycleStage_3.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1816395_1_68996
    }
if(generateOrderNumberComRespDto_2!=null){
      omsExecuteCycleStage_3.setOrderNumber(generateOrderNumberComRespDto_2.getOrderNumber());//SimpleFieldAssign//sourceId:1846352_1_68996
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_3.getExecuteCycleStageId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
      bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((implementFindExecuteCycleByActualWorkTimeComRespDto!= null&& implementFindExecuteCycleByActualWorkTimeComRespDto.getCycleId() == null )){
       //elseif(D3-用目标周期实际开始时间找子周期头部周期ID.周期ID 值等于空 )  68987

//processBranchName:继续循环 ,processBranchId:68988
        continue;
    }
//ModelCode: circulationEnd
        }

//ModelCode: circulationCollections
        for (String circulationCollectionsRes_4: reqDto.getCycleTypeList()){

JudgeCycleTypeIsPlatformComRespDto judgeCycleTypeIsPlatformComRespDto_2 = null;
    JudgeCycleTypeIsPlatformComReqDto judgeCycleTypeIsPlatformComReqDto_1=new JudgeCycleTypeIsPlatformComReqDto();
  if(circulationCollectionsRes_4!=null){
      judgeCycleTypeIsPlatformComReqDto_1.setEndValue(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:966106_1_42998
    }

    /*D3判断周期类型是否平台(公共)[4972]   */
    Assert.isNull(judgeCycleTypeIsPlatformComReqDto_1.getEndValue(),"D3-执行补偿新增标准过程执行周期(公共)-D3判断周期类型是否平台(公共)-周期类型值不能为空",false);
      judgeCycleTypeIsPlatformComRespDto_2 = targetCycleService.judgeCycleTypeIsPlatformCom(judgeCycleTypeIsPlatformComReqDto_1)/*vcase invoke isSameApp*/;



ImplementFindExecuteCycleByActualWorkTimeComRespDto implementFindExecuteCycleByActualWorkTimeComRespDto_2 = null;
    if(judgeCycleTypeIsPlatformComRespDto_2 !=null){
          ImplementFindExecuteCycleByActualWorkTimeComReqDto implementFindExecuteCycleByActualWorkTimeComReqDto_1=new ImplementFindExecuteCycleByActualWorkTimeComReqDto();
  if(circulationCollectionsRes!=null){
      implementFindExecuteCycleByActualWorkTimeComReqDto_1.setTargetActualEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:967143_1_43000
    }
if(circulationCollectionsRes_4!=null){
      implementFindExecuteCycleByActualWorkTimeComReqDto_1.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:966051_1_43000
    }
if(judgeCycleTypeIsPlatformComRespDto_2!=null){
      implementFindExecuteCycleByActualWorkTimeComReqDto_1.setPlatformData(judgeCycleTypeIsPlatformComRespDto_2.getPlatformData());//SimpleFieldAssign//sourceId:966052_1_43000
implementFindExecuteCycleByActualWorkTimeComReqDto_1.setSpaceId(judgeCycleTypeIsPlatformComRespDto_2.getSpaceId());//SimpleFieldAssign//sourceId:966053_1_43000
    }

    /*D3-根据目标周期实际开始结束时间找周期(公共)[6885]   */

      implementFindExecuteCycleByActualWorkTimeComRespDto_2 = implementFindExecuteCycleByActualWorkTimeCom(implementFindExecuteCycleByActualWorkTimeComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
if((implementFindExecuteCycleByActualWorkTimeComRespDto_2!= null&& implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId() != null &&!(circulationCollectionsRes_4!= null&&  circulationCollectionsRes_4 !=null && circulationCollectionsRes_4.equals("DOUBLE_WEEKS")))) {
        //if((D3-用目标周期实际结束时间找子周期尾部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际结束时间）.答案值 不等于 双周))  43001

ImplementTargetContentNextCyclePeriodComRespDto implementTargetContentNextCyclePeriodComRespDto_2 = null;
    ImplementTargetContentNextCyclePeriodComReqDto implementTargetContentNextCyclePeriodComReqDto_1=new ImplementTargetContentNextCyclePeriodComReqDto();
    if(circulationCollectionsRes_4!=null){
      implementTargetContentNextCyclePeriodComReqDto_1.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:984665_1_43123
    }
if(reqDto!=null){
      implementTargetContentNextCyclePeriodComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:984663_1_43123
implementTargetContentNextCyclePeriodComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984664_1_43123
    }

    /*D3-查询目标内容可循环周期类型(公共)[6954]   */
    Assert.isNull(implementTargetContentNextCyclePeriodComReqDto_1.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-周期类型标识不能为空",false);
Assert.isNull(implementTargetContentNextCyclePeriodComReqDto_1.getTargetCycleContentTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementTargetContentNextCyclePeriodComReqDto_1.getEvaluationTemplateId(),"D3-执行补偿新增标准过程执行周期(公共)-D3-查询目标内容可循环周期类型(公共)-冗余评价模板ID不能为空",false);
      implementTargetContentNextCyclePeriodComRespDto_2 = implementTargetContentNextCyclePeriodCom(implementTargetContentNextCyclePeriodComReqDto_1)/*vcase invoke 同服务,同domain*/;



ImplementAnalysisIsLastCycleTypeComRespDto implementAnalysisIsLastCycleTypeComRespDto_2 = null;
          ImplementAnalysisIsLastCycleTypeComReqDto implementAnalysisIsLastCycleTypeComReqDto_1=new ImplementAnalysisIsLastCycleTypeComReqDto();
  if(reqDto!=null){
      implementAnalysisIsLastCycleTypeComReqDto_1.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:967134_1_43004
    }
if(circulationCollectionsRes_4!=null){
      implementAnalysisIsLastCycleTypeComReqDto_1.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:967135_1_43004
    }

    /*D3-分析当前周期类型是否末级周期类型(公共)[6887]   */
    Assert.isNull(implementAnalysisIsLastCycleTypeComReqDto_1.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-D3-分析当前周期类型是否末级周期类型(公共)-周期类型标识不能为空",false);
      implementAnalysisIsLastCycleTypeComRespDto_2 = implementAnalysisIsLastCycleTypeCom(implementAnalysisIsLastCycleTypeComReqDto_1)/*vcase invoke 同服务,同domain*/;



GenerateOrderNumberComRespDto generateOrderNumberComRespDto_3 = null;
    if(implementFindExecuteCycleByActualWorkTimeComRespDto_2 !=null){
          GenerateOrderNumberComReqDto generateOrderNumberComReqDto_2=new GenerateOrderNumberComReqDto();
  if(implementFindExecuteCycleByActualWorkTimeComRespDto_2!=null){
      generateOrderNumberComReqDto_2.setCycleStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:982092_1_43031
    }
if(circulationCollectionsRes!=null){
      generateOrderNumberComReqDto_2.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:982093_1_43031
    }

    /*D3生成周期排序服务(公共)[3545]   */
    Assert.isNull(generateOrderNumberComReqDto_2.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空",false);
Assert.isNull(generateOrderNumberComReqDto_2.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空",false);
      generateOrderNumberComRespDto_3 = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto_2)/*vcase invoke isSameApp*/;



           }
String string_2 = null;
    if(implementFindExecuteCycleByActualWorkTimeComRespDto_2 !=null&&implementTargetContentNextCyclePeriodComRespDto_2 !=null&&implementAnalysisIsLastCycleTypeComRespDto_2 !=null&&generateOrderNumberComRespDto_3 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_4=new OmsExecuteCycleStage();
  omsExecuteCycleStage_4.setIsFatherCycle("FALSE");//sourceId:966117_1_43005
omsExecuteCycleStage_4.setIsSubCycle("FALSE");//sourceId:966118_1_43005
omsExecuteCycleStage_4.setIsMetaphase("FALSE");//sourceId:966119_1_43005
omsExecuteCycleStage_4.setIsProcessCycleStage("TRUE");//sourceId:966120_1_43005
omsExecuteCycleStage_4.setIsStartCycle("FALSE");//sourceId:966125_1_43005
omsExecuteCycleStage_4.setIsEndCycle("FALSE");//sourceId:966126_1_43005
omsExecuteCycleStage_4.setIsCurrentCycle("FALSE");//sourceId:966140_1_43005
omsExecuteCycleStage_4.setIsNextCycle("FALSE");//sourceId:966141_1_43005
if(circulationCollectionsRes!=null){
      omsExecuteCycleStage_4.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:966142_1_43005
omsExecuteCycleStage_4.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:966137_1_43005
omsExecuteCycleStage_4.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:966131_1_43005
omsExecuteCycleStage_4.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:991118_1_43005
omsExecuteCycleStage_4.setEvaTempCreateTime(circulationCollectionsRes.getSortCreateTime());//SimpleFieldAssign//sourceId:966115_1_43005
    }
if(implementFindExecuteCycleByActualWorkTimeComRespDto_2!=null){
      omsExecuteCycleStage_4.setCycleId(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId());//SimpleFieldAssign//sourceId:966114_1_43005
omsExecuteCycleStage_4.setCycleStandardName(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStandardName());//SimpleFieldAssign//sourceId:966135_1_43005
omsExecuteCycleStage_4.setCycleStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:966136_1_43005
omsExecuteCycleStage_4.setFillStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:966130_1_43005
omsExecuteCycleStage_4.setEvaluateStartTime(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleStartTime());//SimpleFieldAssign//sourceId:991117_1_43005
omsExecuteCycleStage_4.setCycleTypeCode(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:966138_1_43005
omsExecuteCycleStage_4.setCycleTypeInstanceCode(implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1605080_1_43005
    }
if(implementTargetContentNextCyclePeriodComRespDto_2!=null){
      omsExecuteCycleStage_4.setNextCyclePeriod(implementTargetContentNextCyclePeriodComRespDto_2.getNextCyclePeriod());//SimpleFieldAssign//sourceId:967576_1_43005
    }
if(implementAnalysisIsLastCycleTypeComRespDto_2!=null){
      omsExecuteCycleStage_4.setIsLastCycle(implementAnalysisIsLastCycleTypeComRespDto_2.getTureOrFalse());//SimpleFieldAssign//sourceId:966127_1_43005
    }
if(generateOrderNumberComRespDto_3!=null){
      omsExecuteCycleStage_4.setOrderNumber(generateOrderNumberComRespDto_3.getOrderNumber());//SimpleFieldAssign//sourceId:966116_1_43005
    }
if(reqDto!=null){
      omsExecuteCycleStage_4.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:966121_1_43005
omsExecuteCycleStage_4.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:966123_1_43005
omsExecuteCycleStage_4.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:966122_1_43005
omsExecuteCycleStage_4.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:966129_1_43005
omsExecuteCycleStage_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:966124_1_43005
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage_4.getEvaObjTargetCycleId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getCycleId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getCycleStandardName(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getFillStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getFillEndtTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsLastCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getOrderNumber(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-周期排序不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsFatherCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsSubCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsMetaphase(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsProcessCycleStage(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsDefinedExecuteCycleStage(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getRelateContentId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getRelateContentTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getTargetId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getEvaluationTemplateId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsStartCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsEndCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getEvaTempCreateTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
      string_2 = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((implementFindExecuteCycleByActualWorkTimeComRespDto_2!= null&& implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId() != null &&circulationCollectionsRes_4!= null&&  circulationCollectionsRes_4 !=null && circulationCollectionsRes_4.equals("DOUBLE_WEEKS"))){
       //elseif((D3-用目标周期实际结束时间找子周期尾部周期ID.周期ID 值不等于空  and M3-过程周期类型发牌【循环开始】（子周期实际结束时间）.答案值 等于 双周))  43058

OmsExecuteCycleStage omsExecuteCycleStage_5 = null;
    QueryExecuteCycleLessEqualStartBigEndDetailReq queryExecuteCycleLessEqualStartBigEndDetailReq=new QueryExecuteCycleLessEqualStartBigEndDetailReq();
  queryExecuteCycleLessEqualStartBigEndDetailReq.setIsProcessCycleStage("TRUE");//sourceId:1816433_1_69007
queryExecuteCycleLessEqualStartBigEndDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1816436_1_69007
if(circulationCollectionsRes!=null){
      queryExecuteCycleLessEqualStartBigEndDetailReq.setCycleStartTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816430_1_69007
queryExecuteCycleLessEqualStartBigEndDetailReq.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816431_1_69007
    }
if(circulationCollectionsRes_4!=null){
      queryExecuteCycleLessEqualStartBigEndDetailReq.setCycleTypeCode(circulationCollectionsRes_4);//SimpleFieldAssign//sourceId:1816432_1_69007
    }
if(reqDto!=null){
      queryExecuteCycleLessEqualStartBigEndDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1816434_1_69007
queryExecuteCycleLessEqualStartBigEndDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1816435_1_69007
    }

    /*3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）[9658]   */
    Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getCycleTypeCode(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getIsProcessCycleStage(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getRelateContentId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getEvaluationTemplateId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleLessEqualStartBigEndDetailReq.getSubjectLifeCycle(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07查询子周期结束时间所在时间范围的双周执行周期（用于裁剪结束时间）-主体生命周期不能为空",false);
      omsExecuteCycleStage_5 = mOmsExecuteCycleStageService.queryExecuteCycleLessEqualStartBigEndDetail(queryExecuteCycleLessEqualStartBigEndDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsExecuteCycleStage_5== null||  omsExecuteCycleStage_5.getExecuteCycleStageId() ==null,"找不到数据，系统异常",false);


GenerateOrderNumberComRespDto generateOrderNumberComRespDto_4 = null;
    if(omsExecuteCycleStage_5 !=null){
          GenerateOrderNumberComReqDto generateOrderNumberComReqDto_3=new GenerateOrderNumberComReqDto();
  if(omsExecuteCycleStage_5!=null){
      generateOrderNumberComReqDto_3.setCycleStartTime(omsExecuteCycleStage_5.getCycleStartTime());//SimpleFieldAssign//sourceId:982092_1_69553
    }
if(circulationCollectionsRes!=null){
      generateOrderNumberComReqDto_3.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:982093_1_69553
    }

    /*D3生成周期排序服务(公共)[3545]   */
    Assert.isNull(generateOrderNumberComReqDto_3.getCycleStartTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期开始时间不能为空",false);
Assert.isNull(generateOrderNumberComReqDto_3.getCycleEndTime(),"D3-执行补偿新增标准过程执行周期(公共)-D3生成周期排序服务(公共)-周期结束时间不能为空",false);
      generateOrderNumberComRespDto_4 = cycleTypeService.generateOrderNumberCom(generateOrderNumberComReqDto_3)/*vcase invoke isSameApp*/;



           }
boolean bOOLEAN_1 ;
    if(omsExecuteCycleStage_5 !=null&&generateOrderNumberComRespDto_4 !=null){
    OmsExecuteCycleStage omsExecuteCycleStage_7=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage_5!=null){
      omsExecuteCycleStage_7.setExecuteCycleStageId(omsExecuteCycleStage_5.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1816391_1_69003
    }
  if(circulationCollectionsRes!=null){
      omsExecuteCycleStage_7.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816392_1_69003
omsExecuteCycleStage_7.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816396_1_69003
omsExecuteCycleStage_7.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1816397_1_69003
           }
if(generateOrderNumberComRespDto_4!=null){
      omsExecuteCycleStage_7.setOrderNumber(generateOrderNumberComRespDto_4.getOrderNumber());//SimpleFieldAssign//sourceId:1846352_1_69003
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_7.getExecuteCycleStageId(),"D3-执行补偿新增标准过程执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
      bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_7)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((implementFindExecuteCycleByActualWorkTimeComRespDto_2!= null&& implementFindExecuteCycleByActualWorkTimeComRespDto_2.getCycleId() == null )){
       //elseif(D3-用目标周期实际结束时间找周期.周期ID 值等于空 )  68998

//processBranchName:继续循环 ,processBranchId:69000
        continue;
    }
//ModelCode: circulationEnd
        }

//ModelCode: circulationEnd
        }

      }
ImplementCompStdExecuteCycleStageComRespDto retData = new ImplementCompStdExecuteCycleStageComRespDto();





return retData;
  }
/**
   * D3设置目标内容实际工作起止时间等[6876]
   * gen by moon at 7/6/2024, 11:56:55 PM
   */
  @Trace(operationName = "D3设置目标内容实际工作起止时间等")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public SetTargetContActualWorkTimeEtcRespDto setTargetContActualWorkTimeEtc(SetTargetContActualWorkTimeEtcReqDto reqDto){


      //virtualUsage D3初始化执行进度(0%)  47365
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto.setExecuteProgressValue(Double.valueOf("0"));//CUSTOM_CONVENTION//sourceId:1081526_1_47365
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081529_1_47365
implementStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081530_1_47365
implementStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081532_1_47365
    }

    /*D3初始化执行进度(0%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getObjectId(),"D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3初始化执行进度(0%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3查目标父周期详请  67549
      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1756403_1_67549
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1756402_1_67549
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756404_1_67549
    }

    /*D3查目标父周期详请[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3设置目标内容实际工作起止时间等-D3查目标父周期详请-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3查目标父周期详请-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3设置目标内容实际工作起止时间等-D3查目标父周期详请-是否存档不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3更新执行进度(5%)  67550
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_1 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_1=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_1.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67550
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_1.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67550
implementStatisticsUpdateExecuteProgressComReqDto_1.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67550
implementStatisticsUpdateExecuteProgressComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67550
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_1.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_1 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_1)/*vcase invoke isSameApp*/;



if((queryEvaObjTargetCyclePlatformDetailComRespDto!= null&&  queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode() !=null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(D3查目标内容父周期详请.关联目标内容类型编码 等于 目标)  42967

      SetTargetContActualWorkTimeComRespDto setTargetContActualWorkTimeComRespDto = null;
    SetTargetContActualWorkTimeComReqDto setTargetContActualWorkTimeComReqDto=new SetTargetContActualWorkTimeComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      setTargetContActualWorkTimeComReqDto.setTargetCyclePsetList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetCyclePsetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:964184_1_67520
    }
if(reqDto!=null){
      setTargetContActualWorkTimeComReqDto.setTargetCycleParentCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:964180_1_67520
setTargetContActualWorkTimeComReqDto.setTargetCycleMidCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:964181_1_67520
setTargetContActualWorkTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964183_1_67520
    }

    /*D3设置目标内容成果汇报时间(公共)[6868]   */
    Assert.isNull(setTargetContActualWorkTimeComReqDto.getTargetCycleParentCycleId(),"D3设置目标内容实际工作起止时间等-D3设置目标内容成果汇报时间(公共)-目标周期父周期ID不能为空",false);
Assert.isNull(setTargetContActualWorkTimeComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3设置目标内容成果汇报时间(公共)-冗余评价模板ID不能为空",false);
      setTargetContActualWorkTimeComRespDto = setTargetContActualWorkTimeCom(setTargetContActualWorkTimeComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_2 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_2=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_2.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67551
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_2.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67551
implementStatisticsUpdateExecuteProgressComReqDto_2.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67551
implementStatisticsUpdateExecuteProgressComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67551
    }

    /*D3更新执行进度(20%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_2.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_2 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_2)/*vcase invoke isSameApp*/;



AddStandardExecuteCycleStageComComRespDto addStandardExecuteCycleStageComComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          AddStandardExecuteCycleStageComComReqDto addStandardExecuteCycleStageComComReqDto=new AddStandardExecuteCycleStageComComReqDto();
  if(reqDto!=null){
      addStandardExecuteCycleStageComComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsOpenCustomExecuteCycle());//SimpleFieldAssign//sourceId:1756408_1_42968
addStandardExecuteCycleStageComComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981777_1_42968
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      addStandardExecuteCycleStageComComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:981775_1_42968
addStandardExecuteCycleStageComComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:981776_1_42968
    }

    /*D3-新增标准执行周期阶段(公共)[6870]   */
    Assert.isNull(addStandardExecuteCycleStageComComReqDto.getIsDefinedExecuteCycleStage(),"D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-是否自定义执行周期阶段不能为空",false);
    Assert.isNull(addStandardExecuteCycleStageComComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addStandardExecuteCycleStageComComReqDto.getTargetCycleContentTypeCode(),"D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addStandardExecuteCycleStageComComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3-新增标准执行周期阶段(公共)-冗余评价模板ID不能为空",false);
      addStandardExecuteCycleStageComComRespDto = addStandardExecuteCycleStageComCom(addStandardExecuteCycleStageComComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_3 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_3=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_3.setExecuteProgressValue(Double.valueOf("30"));//CUSTOM_CONVENTION//sourceId:1081561_1_47367
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_3.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081564_1_47367
implementStatisticsUpdateExecuteProgressComReqDto_3.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081565_1_47367
implementStatisticsUpdateExecuteProgressComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081567_1_47367
    }

    /*D3更新执行进度(30%）[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_3.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(30%）-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_3 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_3)/*vcase invoke isSameApp*/;



RefreshSpecExecCycleStageComRespDto refreshSpecExecCycleStageComRespDto = null;
    if(addStandardExecuteCycleStageComComRespDto !=null&&queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          RefreshSpecExecCycleStageComReqDto refreshSpecExecCycleStageComReqDto=new RefreshSpecExecCycleStageComReqDto();
  if(addStandardExecuteCycleStageComComRespDto!=null){
      refreshSpecExecCycleStageComReqDto.setCycleMode(addStandardExecuteCycleStageComComRespDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1922998_1_43461
refreshSpecExecCycleStageComReqDto.setSubcycleType(addStandardExecuteCycleStageComComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1922999_1_43461
    }
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      refreshSpecExecCycleStageComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:981146_1_43461
refreshSpecExecCycleStageComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:981147_1_43461
refreshSpecExecCycleStageComReqDto.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:981145_1_43461
    }
if(reqDto!=null){
      refreshSpecExecCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981144_1_43461
    }

    /*D3-更新目标内容执行周期时段规则[4983]   */
    Assert.isNull(refreshSpecExecCycleStageComReqDto.getCycleMode(),"D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-周期模式不能为空",false);
Assert.isNull(refreshSpecExecCycleStageComReqDto.getSubcycleType(),"D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-子周期周期类型不能为空",false);
    Assert.isNull(refreshSpecExecCycleStageComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-关联目标内容ID不能为空",false);
Assert.isNull(refreshSpecExecCycleStageComReqDto.getTargetCycleContentTypeCode(),"D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-关联目标内容类型编码不能为空",false);
Assert.isNull(refreshSpecExecCycleStageComReqDto.getTargetId(),"D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-冗余目标ID不能为空",false);
Assert.isNull(refreshSpecExecCycleStageComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3-更新目标内容执行周期时段规则-冗余评价模板ID不能为空",false);
      refreshSpecExecCycleStageComRespDto = targetCycleService.refreshSpecExecCycleStageCom(refreshSpecExecCycleStageComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_4 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_4=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_4.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_47370
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_4.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_47370
implementStatisticsUpdateExecuteProgressComReqDto_4.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_47370
implementStatisticsUpdateExecuteProgressComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_47370
    }

    /*D3更新执行进度(20%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_4.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_4 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_4)/*vcase invoke isSameApp*/;



if((refreshSpecExecCycleStageComRespDto!= null&&  refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel() !=null && refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel().equals("EVA_TEMP_LEVEL")||refreshSpecExecCycleStageComRespDto!= null&&  refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel() !=null && refreshSpecExecCycleStageComRespDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL"))) {
        //if((D3-更新目标内容执行周期时段规则.时段规则设置级别 等于 评价模板级 or D3-更新目标内容执行周期时段规则.时段规则设置级别 等于 周期类型级))  43463

RefreshHolidaysAndFestivalsComRespDto refreshHolidaysAndFestivalsComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          RefreshHolidaysAndFestivalsComReqDto refreshHolidaysAndFestivalsComReqDto=new RefreshHolidaysAndFestivalsComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      refreshHolidaysAndFestivalsComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:985636_1_43464
    }
if(reqDto!=null){
      refreshHolidaysAndFestivalsComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:981143_1_43464
    }

    /*D3-补偿处理目标内容自定义执行周期节假日[4929]   */
    Assert.isNull(refreshHolidaysAndFestivalsComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3-补偿处理目标内容自定义执行周期节假日-关联目标内容ID不能为空",false);
Assert.isNull(refreshHolidaysAndFestivalsComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3-补偿处理目标内容自定义执行周期节假日-冗余评价模板ID不能为空",false);
      refreshHolidaysAndFestivalsComRespDto = targetCycleService.refreshHolidaysAndFestivalsCom(refreshHolidaysAndFestivalsComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_5 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_5=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_5.setExecuteProgressValue(Double.valueOf("10"));//CUSTOM_CONVENTION//sourceId:1081591_1_49312
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_5.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081594_1_49312
implementStatisticsUpdateExecuteProgressComReqDto_5.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081595_1_49312
implementStatisticsUpdateExecuteProgressComReqDto_5.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081597_1_49312
      }

    /*D3更新执行进度(10%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_5.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_5 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_5)/*vcase invoke isSameApp*/;



      }
else{
       //else  67556

ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_6 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_6=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_6.setExecuteProgressValue(Double.valueOf("10"));//CUSTOM_CONVENTION//sourceId:1081591_1_67557
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_6.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081594_1_67557
implementStatisticsUpdateExecuteProgressComReqDto_6.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081595_1_67557
implementStatisticsUpdateExecuteProgressComReqDto_6.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081597_1_67557
    }

    /*D3更新执行进度(10%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_6.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(10%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_6 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_6)/*vcase invoke isSameApp*/;



      }
ImplementWhetherPastExecutionPeriodIsLastDisposeComRespDto implementWhetherPastExecutionPeriodIsLastDisposeComRespDto = null;
    if(addStandardExecuteCycleStageComComRespDto !=null){
          ImplementWhetherPastExecutionPeriodIsLastDisposeComReqDto implementWhetherPastExecutionPeriodIsLastDisposeComReqDto=new ImplementWhetherPastExecutionPeriodIsLastDisposeComReqDto();
  if(addStandardExecuteCycleStageComComRespDto!=null){
      implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setPeriodicModeTypeCode(addStandardExecuteCycleStageComComRespDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1655007_1_64995
implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setLastCycleType(addStandardExecuteCycleStageComComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1655010_1_64995
implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setSecondLastCycleType(addStandardExecuteCycleStageComComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1655008_1_64995
    }
if(reqDto!=null){
      implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1655009_1_64995
    }

    /*D3执行过往执行周期是否末级处理(公共)[8774]   */
    Assert.isNull(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.getPeriodicModeTypeCode(),"D3设置目标内容实际工作起止时间等-D3执行过往执行周期是否末级处理(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.getLastCycleType(),"D3设置目标内容实际工作起止时间等-D3执行过往执行周期是否末级处理(公共)-末级周期类型不能为空",false);
Assert.isNull(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3执行过往执行周期是否末级处理(公共)-冗余评价模板ID不能为空",false);
      implementWhetherPastExecutionPeriodIsLastDisposeComRespDto = executeCycleService.implementWhetherPastExecutionPeriodIsLastDisposeCom(implementWhetherPastExecutionPeriodIsLastDisposeComReqDto)/*vcase invoke isSameApp*/;



      }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_7 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_7=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_7.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67552
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_7.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67552
implementStatisticsUpdateExecuteProgressComReqDto_7.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67552
implementStatisticsUpdateExecuteProgressComReqDto_7.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67552
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_7.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_7 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_7)/*vcase invoke isSameApp*/;



ImplementInitializeUpdateTargetContCurrentCycleComRespDto implementInitializeUpdateTargetContCurrentCycleComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementInitializeUpdateTargetContCurrentCycleComReqDto implementInitializeUpdateTargetContCurrentCycleComReqDto=new ImplementInitializeUpdateTargetContCurrentCycleComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetContentName(queryEvaObjTargetCyclePlatformDetailComRespDto.getCyclelAlias());//SimpleFieldAssign//sourceId:1151198_1_67519
implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1151211_1_67519
implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1151212_1_67519
implementInitializeUpdateTargetContCurrentCycleComReqDto.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1151202_1_67519
    }
if(reqDto!=null){
      implementInitializeUpdateTargetContCurrentCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1151201_1_67519
    }

    /*D3执行初始化更新目标内容当前及下一周期(公共)[7473]   */
    Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetContentName(),"D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-目标内容名称不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentTypeCode(),"D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getTargetId(),"D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementInitializeUpdateTargetContCurrentCycleComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3执行初始化更新目标内容当前及下一周期(公共)-冗余评价模板ID不能为空",false);
      implementInitializeUpdateTargetContCurrentCycleComRespDto = targetContentService.implementInitializeUpdateTargetContCurrentCycleCom(implementInitializeUpdateTargetContCurrentCycleComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_8 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_8=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_8.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67553


    if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_8.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67553
implementStatisticsUpdateExecuteProgressComReqDto_8.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67553
implementStatisticsUpdateExecuteProgressComReqDto_8.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67553
    }
    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_8.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_8 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_8)/*vcase invoke isSameApp*/;



RefreshBizAppServiceContCurrentBstepComRespDto refreshBizAppServiceContCurrentBstepComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          RefreshBizAppServiceContCurrentBstepComReqDto refreshBizAppServiceContCurrentBstepComReqDto=new RefreshBizAppServiceContCurrentBstepComReqDto();
  refreshBizAppServiceContCurrentBstepComReqDto.setBizSceneCode("ADD_EVA_TEMP");//CUSTOM_CONVENTION//sourceId:980933_1_42975
refreshBizAppServiceContCurrentBstepComReqDto.setStepObj("OMS_EVALUATION_SUBJECT");//sourceId:980934_1_42975
refreshBizAppServiceContCurrentBstepComReqDto.setOrderNumber(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:980932_1_42975
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      refreshBizAppServiceContCurrentBstepComReqDto.setEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:980931_1_42975
    }

    /*D3-更新评价主题当前步骤(第5步)[4593]   */
    Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getBizSceneCode(),"D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-业务场景标识不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getEntityId(),"D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-步骤内容实例ID不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getStepObj(),"D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-步骤使用对象表不能为空",false);
Assert.isNull(refreshBizAppServiceContCurrentBstepComReqDto.getOrderNumber(),"D3设置目标内容实际工作起止时间等-D3-更新评价主题当前步骤(第5步)-排序不能为空",false);
      refreshBizAppServiceContCurrentBstepComRespDto = offStateService.refreshBizAppServiceContCurrentBstepCom(refreshBizAppServiceContCurrentBstepComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_9 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_9=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_9.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67555
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_9.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67555
implementStatisticsUpdateExecuteProgressComReqDto_9.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67555
implementStatisticsUpdateExecuteProgressComReqDto_9.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67555
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_9.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_9 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_9)/*vcase invoke isSameApp*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_10 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_10=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_10.setIsComplete("TRUE");//sourceId:1081809_1_67554
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_10.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081574_1_67554
implementStatisticsUpdateExecuteProgressComReqDto_10.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081575_1_67554
implementStatisticsUpdateExecuteProgressComReqDto_10.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081577_1_67554
      }

    /*D3更新执行进度(已完成)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getIsComplete(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_10.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_10 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_10)/*vcase invoke isSameApp*/;



      }
else if((queryEvaObjTargetCyclePlatformDetailComRespDto!= null&&  queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode() !=null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")||queryEvaObjTargetCyclePlatformDetailComRespDto!= null&&  queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode() !=null && queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif((D3查目标内容父周期详请.关联目标内容类型编码 等于 目标分类 or D3查目标内容父周期详请.关联目标内容类型编码 等于 指标))  42969

AnalysisOverwriteTargetContCustomReportComRespDto analysisOverwriteTargetContCustomReportComRespDto = null;
    AnalysisOverwriteTargetContCustomReportComReqDto analysisOverwriteTargetContCustomReportComReqDto=new AnalysisOverwriteTargetContCustomReportComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      analysisOverwriteTargetContCustomReportComReqDto.setEvaObjTargetCycleList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1756856_1_67572
    }
if(reqDto!=null){
      analysisOverwriteTargetContCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756855_1_67572
    }

    /*D3分析回写目标内容自定义汇报(公共)[9452]   */
    Assert.isNull(analysisOverwriteTargetContCustomReportComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3分析回写目标内容自定义汇报(公共)-冗余评价模板ID不能为空",false);
      analysisOverwriteTargetContCustomReportComRespDto = analysisOverwriteTargetContCustomReportCom(analysisOverwriteTargetContCustomReportComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_11 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_11=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_11.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67580
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_11.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67580
implementStatisticsUpdateExecuteProgressComReqDto_11.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67580
implementStatisticsUpdateExecuteProgressComReqDto_11.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67580
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_11.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_11 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_11)/*vcase invoke isSameApp*/;



PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto=new PreparationTargetContExtendInfoComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1754854_1_67518
preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1754855_1_67518
    }
if(reqDto!=null){
      preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1754856_1_67518
    }

    /*D3查询目标内容是否开启自定义执行周期(公共)[8590]   */
    Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3查询目标内容是否开启自定义执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(),"D3设置目标内容实际工作起止时间等-D3查询目标内容是否开启自定义执行周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3查询目标内容是否开启自定义执行周期(公共)-冗余评价模板ID不能为空",false);
      preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;



           }
if((preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE")&&preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport().equals("TRUE"))) {
        //if((D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义执行周期 等于 是 and D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义汇报 等于 是))  42972

ImplementOverwriteDelCustomExeCycleComRespDto implementOverwriteDelCustomExeCycleComRespDto = null;
    ImplementOverwriteDelCustomExeCycleComReqDto implementOverwriteDelCustomExeCycleComReqDto=new ImplementOverwriteDelCustomExeCycleComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      implementOverwriteDelCustomExeCycleComReqDto.setEvaObjTargetCycleList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1755412_1_67522
    }
  if(reqDto!=null){
      implementOverwriteDelCustomExeCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755411_1_67522
    }

    /*D3执行回删自定义执行周期(公共)[9449]   */
    Assert.isNull(implementOverwriteDelCustomExeCycleComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3执行回删自定义执行周期(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteDelCustomExeCycleComRespDto = implementOverwriteDelCustomExeCycleCom(implementOverwriteDelCustomExeCycleComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_12 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_12=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_12.setExecuteProgressValue(Double.valueOf("90"));//CUSTOM_CONVENTION//sourceId:1756865_1_67583
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_12.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1756867_1_67583
implementStatisticsUpdateExecuteProgressComReqDto_12.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1756868_1_67583
implementStatisticsUpdateExecuteProgressComReqDto_12.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756869_1_67583
    }

    /*D3更新执行进度(90%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_12.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(90%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_12 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_12)/*vcase invoke isSameApp*/;



      }
else if((preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("FALSE")&&preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomReport().equals("TRUE"))){
       //elseif((D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义执行周期 等于 否 and D3查询目标内容是否开启自定义执行周期(公共).是否开启自定义汇报 等于 是))  67521

ImplementAmendTargetContOpenCustomExecuteCycleComRespDto implementAmendTargetContOpenCustomExecuteCycleComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementAmendTargetContOpenCustomExecuteCycleComReqDto implementAmendTargetContOpenCustomExecuteCycleComReqDto=new ImplementAmendTargetContOpenCustomExecuteCycleComReqDto();
  implementAmendTargetContOpenCustomExecuteCycleComReqDto.setIsOpenCustomExecuteCycle("TRUE");//sourceId:1756330_1_67545
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      implementAmendTargetContOpenCustomExecuteCycleComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756331_1_67545
implementAmendTargetContOpenCustomExecuteCycleComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1756332_1_67545
    }
if(reqDto!=null){
      implementAmendTargetContOpenCustomExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756333_1_67545
    }

    /*D3回写目标内容开启自定义执行周期(公共)[9378]   */
    Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getIsOpenCustomExecuteCycle(),"D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-是否开启自定义执行周期不能为空",false);
Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getTargetCycleContentTypeCode(),"D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAmendTargetContOpenCustomExecuteCycleComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3回写目标内容开启自定义执行周期(公共)-冗余评价模板ID不能为空",false);
      implementAmendTargetContOpenCustomExecuteCycleComRespDto = indexSystemService.implementAmendTargetContOpenCustomExecuteCycleCom(implementAmendTargetContOpenCustomExecuteCycleComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_13 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_13=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_13.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67565
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_13.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67565
implementStatisticsUpdateExecuteProgressComReqDto_13.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67565
implementStatisticsUpdateExecuteProgressComReqDto_13.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67565
    }

    /*D3更新执行进度(20%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_13.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_13 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_13)/*vcase invoke isSameApp*/;



QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto_1=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsSubCycle("TRUE");//sourceId:1756943_1_67586
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1756944_1_67586
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1756940_1_67586
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1756941_1_67586
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756942_1_67586
    }
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756945_1_67586
    }

    /*D3查目标内容子周期周期类型标识[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjEntityId(),"D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjTypeCode(),"D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsSubCycle(),"D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsArchive(),"D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3查目标内容子周期周期类型标识-冗余评价模板ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto_2 = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto_1)/*vcase invoke isSameApp*/;



           }
AddTargetConExecuteCycleStageComRespDto addTargetConExecuteCycleStageComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null&&queryEvaObjTargetCyclePlatformDetailComRespDto_2 !=null){
          AddTargetConExecuteCycleStageComReqDto addTargetConExecuteCycleStageComReqDto=new AddTargetConExecuteCycleStageComReqDto();
  addTargetConExecuteCycleStageComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1755416_1_67523
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      addTargetConExecuteCycleStageComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1755420_1_67523
addTargetConExecuteCycleStageComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1755419_1_67523
addTargetConExecuteCycleStageComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1755414_1_67523
addTargetConExecuteCycleStageComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1755413_1_67523
addTargetConExecuteCycleStageComReqDto.setTargetId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1755417_1_67523
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto_2!=null){
      addTargetConExecuteCycleStageComReqDto.setSubcycleType(queryEvaObjTargetCyclePlatformDetailComRespDto_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1755418_1_67523
    }
if(reqDto!=null){
      addTargetConExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755415_1_67523
    }

    /*D3新增目标内容执行周期阶段(公共)[9387]   */
    Assert.isNull(addTargetConExecuteCycleStageComReqDto.getEvaObjEntityId(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getEvaObjTypeCode(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-被评对象类型编码不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getTargetCycleContentTypeCode(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getSubcycleType(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-子周期周期类型不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getTargetId(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-冗余目标ID不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetConExecuteCycleStageComReqDto.getSpaceId(),"D3设置目标内容实际工作起止时间等-D3新增目标内容执行周期阶段(公共)-创建于空间ID不能为空",false);
      addTargetConExecuteCycleStageComRespDto = addTargetConExecuteCycleStageCom(addTargetConExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_14 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_14=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_14.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67567
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_14.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67567
implementStatisticsUpdateExecuteProgressComReqDto_14.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67567
implementStatisticsUpdateExecuteProgressComReqDto_14.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67567
    }

    /*D3更新执行进度(20%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_14.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_14 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_14)/*vcase invoke isSameApp*/;



ImplementOverwriteDelCustomExeCycleComRespDto implementOverwriteDelCustomExeCycleComRespDto_1 = null;
    ImplementOverwriteDelCustomExeCycleComReqDto implementOverwriteDelCustomExeCycleComReqDto_1=new ImplementOverwriteDelCustomExeCycleComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      implementOverwriteDelCustomExeCycleComReqDto_1.setEvaObjTargetCycleList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1755412_1_67524
    }
if(reqDto!=null){
      implementOverwriteDelCustomExeCycleComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755411_1_67524
    }

    /*D3执行回删自定义执行周期(公共)[9449]   */
    Assert.isNull(implementOverwriteDelCustomExeCycleComReqDto_1.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3执行回删自定义执行周期(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteDelCustomExeCycleComRespDto_1 = implementOverwriteDelCustomExeCycleCom(implementOverwriteDelCustomExeCycleComReqDto_1)/*vcase invoke 同服务,同domain*/;



      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_15 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_15=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_15.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67568
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_15.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67568
implementStatisticsUpdateExecuteProgressComReqDto_15.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67568
implementStatisticsUpdateExecuteProgressComReqDto_15.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67568
    }

    /*D3更新执行进度(20%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_15.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_15 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_15)/*vcase invoke isSameApp*/;



ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto implementOverwriteDelTargetContReportTimerTaskPlanComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementOverwriteDelTargetContReportTimerTaskPlanComReqDto implementOverwriteDelTargetContReportTimerTaskPlanComReqDto=new ImplementOverwriteDelTargetContReportTimerTaskPlanComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1756328_1_67544
implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1756329_1_67544
implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756326_1_67544
    }
if(reqDto!=null){
      implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756327_1_67544
    }

    /*D3回删目标内容汇报任务任务调度(公共)[9451]   */
    Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getEvaObjEntityId(),"D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getEvaObjTypeCode(),"D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-被评对象类型编码不能为空",false);
Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getTargetCycleContentId(),"D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3回删目标内容汇报任务任务调度(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteDelTargetContReportTimerTaskPlanComRespDto = implementOverwriteDelTargetContReportTimerTaskPlanCom(implementOverwriteDelTargetContReportTimerTaskPlanComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_16 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_16=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_16.setExecuteProgressValue(Double.valueOf("20"));//CUSTOM_CONVENTION//sourceId:1081540_1_67569
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_16.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081543_1_67569
implementStatisticsUpdateExecuteProgressComReqDto_16.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081544_1_67569
implementStatisticsUpdateExecuteProgressComReqDto_16.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081546_1_67569
    }

    /*D3更新执行进度(20%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_16.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(20%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_16 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_16)/*vcase invoke isSameApp*/;



ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto = null;
    ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto=new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
  if(reqDto!=null){
      implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1755947_1_67546
implementOverwriteTargetContFatherOrMidReportTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755946_1_67546
    }

    /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
    Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaObjTargetCycleId(),"D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteTargetContFatherOrMidReportTimeComRespDto = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_17 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_17=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_17.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67581
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_17.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67581
implementStatisticsUpdateExecuteProgressComReqDto_17.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67581
implementStatisticsUpdateExecuteProgressComReqDto_17.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67581
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_17.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_17 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_17)/*vcase invoke isSameApp*/;



if((reqDto!= null&& reqDto.getTargetCycleMidCycleId() != null )) {
        //if(D3设置目标内容实际工作起止时间等.目标周期中期ID 值不等于空 )  67547

ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = null;
    ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1=new ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto();
  if(reqDto!=null){
      implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1755947_1_67548
implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755946_1_67548
    }

    /*D3回写目标内容父或中成果汇报时间(公共)[9450]   */
    Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaObjTargetCycleId(),"D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1.getEvaluationTemplateId(),"D3设置目标内容实际工作起止时间等-D3回写目标内容父或中成果汇报时间(公共)-冗余评价模板ID不能为空",false);
      implementOverwriteTargetContFatherOrMidReportTimeComRespDto_1 = implementOverwriteTargetContFatherOrMidReportTimeCom(implementOverwriteTargetContFatherOrMidReportTimeComReqDto_1)/*vcase invoke 同服务,同domain*/;



ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_18 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_18=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_18.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67577
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_18.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67577
implementStatisticsUpdateExecuteProgressComReqDto_18.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67577
implementStatisticsUpdateExecuteProgressComReqDto_18.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67577
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_18.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_18 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_18)/*vcase invoke isSameApp*/;



      }
else{
       //else  67576

ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_19 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_19=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_19.setExecuteProgressValue(Double.valueOf("5"));//CUSTOM_CONVENTION//sourceId:1081581_1_67578
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_19.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081584_1_67578
implementStatisticsUpdateExecuteProgressComReqDto_19.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081585_1_67578
implementStatisticsUpdateExecuteProgressComReqDto_19.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081587_1_67578
    }

    /*D3更新执行进度(5%)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getExecuteProgressValue(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-执行进度值不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_19.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(5%)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_19 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_19)/*vcase invoke isSameApp*/;



    }
    }
ImplementStatisticsUpdateExecuteProgressComRespDto implementStatisticsUpdateExecuteProgressComRespDto_20 = null;
    ImplementStatisticsUpdateExecuteProgressComReqDto implementStatisticsUpdateExecuteProgressComReqDto_20=new ImplementStatisticsUpdateExecuteProgressComReqDto();
  implementStatisticsUpdateExecuteProgressComReqDto_20.setIsComplete("TRUE");//sourceId:1081809_1_67585
if(reqDto!=null){
      implementStatisticsUpdateExecuteProgressComReqDto_20.setObjectId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1081574_1_67585
implementStatisticsUpdateExecuteProgressComReqDto_20.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1081575_1_67585
implementStatisticsUpdateExecuteProgressComReqDto_20.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1081577_1_67585
    }

    /*D3更新执行进度(已完成)[7094]   */
    Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getIsComplete(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-是否已完成不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getObjectId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-归属对象内容ID不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getUseTypeCode(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-用途类型编码不能为空",false);
Assert.isNull(implementStatisticsUpdateExecuteProgressComReqDto_20.getThemeContentId(),"D3设置目标内容实际工作起止时间等-D3更新执行进度(已完成)-主题内容ID不能为空",false);
      implementStatisticsUpdateExecuteProgressComRespDto_20 = executeProgressService.implementStatisticsUpdateExecuteProgressCom(implementStatisticsUpdateExecuteProgressComReqDto_20)/*vcase invoke isSameApp*/;



    }
SetTargetContActualWorkTimeEtcRespDto retData = new SetTargetContActualWorkTimeEtcRespDto();





return retData;
  }
/**
   * D3获取上级目标内容实际工作起止时间[6877]
   * gen by moon at 5/25/2023, 12:20:47 AM
   */
  @Trace(operationName = "D3获取上级目标内容实际工作起止时间")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainParentTargetContActualWorkTimeRespDto obtainParentTargetContActualWorkTime(ObtainParentTargetContActualWorkTimeReqDto reqDto){


      OmsTargetCyclePlanSet omsTargetCyclePlanSet_1 =null;
//virtualUsage 3-3-09查当前目标周期详情  42999
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:964593_1_42999
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964591_1_42999
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964592_1_42999
    }

    /*3-3-09查当前目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-09查当前目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-09查当前目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-09查当前目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))||(omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE"))||(omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))) {
        //if((3-3-09查当前目标周期详情.是否子周期 等于 是 and 3-3-09查当前目标周期详情.是否父周期 等于 否 and 3-3-09查当前目标周期详情.是否中期 等于 否) or (3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 是 and 3-3-09查当前目标周期详情.是否中期 等于 是) or (3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 是 and 3-3-09查当前目标周期详情.是否中期 等于 否))  43006

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsSubCycle("TRUE");//sourceId:964831_1_43007
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:964833_1_43007
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964827_1_43007
queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:964828_1_43007
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:964829_1_43007
queryEvaObjTargetCycleDetailReq_1.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:964830_1_43007
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964832_1_43007
    }

    /*3-3-09查上级目标子周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleCode(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsSubCycle(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标子周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq=new QueryTargetCyclePsetDetailReq();
  queryTargetCyclePsetDetailReq.setIsArchive("FALSE");//sourceId:964748_1_43008
queryTargetCyclePsetDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964743_1_43008
if(omsEvaluationObjectTargetCycle_2!=null){
      queryTargetCyclePsetDetailReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964741_1_43008
    }
if(reqDto!=null){
      queryTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964746_1_43008
    }

    /*3-3-08查目标周期规划设置（实际工作开始与结束时间）[3368]   */
    Assert.isNull(queryTargetCyclePsetDetailReq.getEvaObjTargetCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-是否存档不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq.getSpaceId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-创建于空间ID不能为空",false);
      omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetCyclePlanSet_1 = omsTargetCyclePlanSet;
           }
      }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))||(omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsSubCycle() !=null && omsEvaluationObjectTargetCycle.getIsSubCycle().equals("FALSE"))){
       //elseif((3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 否 and 3-3-09查当前目标周期详情.是否中期 等于 否) or (3-3-09查当前目标周期详情.是否父周期 等于 是 and 3-3-09查当前目标周期详情.是否中期 等于 是 and 3-3-09查当前目标周期详情.是否子周期 等于 否))  43009

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:964991_1_43011
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_2.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964986_1_43011
queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:964987_1_43011
queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:964988_1_43011
queryEvaObjTargetCycleDetailReq_2.setIsParentCycle(omsEvaluationObjectTargetCycle.getIsParentCycle());//SimpleFieldAssign//sourceId:964989_1_43011
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964990_1_43011
    }

    /*3-3-09查上级目标周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getParentEvaObjTargetCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
OmsTargetCyclePlanSet omsTargetCyclePlanSet_2 = null;
    if(omsEvaluationObjectTargetCycle_4 !=null){
          QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq_1=new QueryTargetCyclePsetDetailReq();
  queryTargetCyclePsetDetailReq_1.setIsArchive("FALSE");//sourceId:964748_1_43012
queryTargetCyclePsetDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964743_1_43012
if(omsEvaluationObjectTargetCycle_4!=null){
      queryTargetCyclePsetDetailReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_4.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964741_1_43012
    }
if(reqDto!=null){
      queryTargetCyclePsetDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964746_1_43012
    }

    /*3-3-08查目标周期规划设置（实际工作开始与结束时间）[3368]   */
    Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaObjTargetCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_1.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-是否存档不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_1.getSpaceId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-创建于空间ID不能为空",false);
      omsTargetCyclePlanSet_2 = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetCyclePlanSet_1 = omsTargetCyclePlanSet_2;
           }
    }
else if((omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("TRUE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsParentCycle() !=null && omsEvaluationObjectTargetCycle.getIsParentCycle().equals("FALSE")&&omsEvaluationObjectTargetCycle!= null&&  omsEvaluationObjectTargetCycle.getIsMetaphase() !=null && omsEvaluationObjectTargetCycle.getIsMetaphase().equals("FALSE"))){
       //elseif((3-3-09查当前目标周期详情.是否中期 等于 是 and 3-3-09查当前目标周期详情.是否父周期 等于 否 and 3-3-09查当前目标周期详情.是否中期 等于 否))  43010

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_6 = null;
    if(omsEvaluationObjectTargetCycle !=null){
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_3=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_3.setIsArchive("FALSE");//sourceId:964991_1_43015
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_3.setParentEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964986_1_43015
queryEvaObjTargetCycleDetailReq_3.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:964987_1_43015
queryEvaObjTargetCycleDetailReq_3.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:964988_1_43015
queryEvaObjTargetCycleDetailReq_3.setIsMetaphase(omsEvaluationObjectTargetCycle.getIsMetaphase());//SimpleFieldAssign//sourceId:981148_1_43015
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964990_1_43015
    }

    /*3-3-09查上级目标周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getParentEvaObjTargetCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-上级被评对象目标周期标识不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getEvaObjEntityId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getEvaObjTypeCode(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_3.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-09查上级目标周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_6 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
OmsTargetCyclePlanSet omsTargetCyclePlanSet_3 = null;
    if(omsEvaluationObjectTargetCycle_6 !=null){
          QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq_2=new QueryTargetCyclePsetDetailReq();
  queryTargetCyclePsetDetailReq_2.setIsArchive("FALSE");//sourceId:964748_1_43013
queryTargetCyclePsetDetailReq_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:964743_1_43013
if(omsEvaluationObjectTargetCycle_6!=null){
      queryTargetCyclePsetDetailReq_2.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_6.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:964741_1_43013
    }
if(reqDto!=null){
      queryTargetCyclePsetDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964746_1_43013
    }

    /*3-3-08查目标周期规划设置（实际工作开始与结束时间）[3368]   */
    Assert.isNull(queryTargetCyclePsetDetailReq_2.getEvaObjTargetCycleId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_2.getEvaluationTemplateId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_2.getIsArchive(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-是否存档不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_2.getSpaceId(),"D3获取上级目标内容实际工作起止时间-3-3-08查目标周期规划设置（实际工作开始与结束时间）-创建于空间ID不能为空",false);
      omsTargetCyclePlanSet_3 = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


      omsTargetCyclePlanSet_1 = omsTargetCyclePlanSet_3;
           }
    }
ObtainParentTargetContActualWorkTimeRespDto retData = new ObtainParentTargetContActualWorkTimeRespDto();
  if(omsTargetCyclePlanSet_1!=null){
      retData.setTargetCyclePlanSetId(omsTargetCyclePlanSet_1.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:965084_1
retData.setTargetActualStartTime(omsTargetCyclePlanSet_1.getTargetActualStartTime());//SimpleFieldAssign//sourceId:965085_1
retData.setTargetActualEndtTime(omsTargetCyclePlanSet_1.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:965086_1
    }




return retData;
  }
/**
   * D3-分析时段规则设置(公共)[6879]
   * gen by moon at 5/21/2023, 7:04:24 AM
   */
  @Trace(operationName = "D3-分析时段规则设置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTimeRulesSetLevelComRespDto implementTimeRulesSetLevelCom(ImplementTimeRulesSetLevelComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage D2-3查时段规则设置规则配置  42368
      QueryConfItemMatchEvaTempAnswerDetailComRespDto queryConfItemMatchEvaTempAnswerDetailComRespDto = null;
    QueryConfItemMatchEvaTempAnswerDetailComReqDto queryConfItemMatchEvaTempAnswerDetailComReqDto=new QueryConfItemMatchEvaTempAnswerDetailComReqDto();
  queryConfItemMatchEvaTempAnswerDetailComReqDto.setConfItemCode("TIME_RULES_SET_LEVEL");//CUSTOM_CONVENTION//sourceId:964835_1_42368
queryConfItemMatchEvaTempAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:964872_1_42368
queryConfItemMatchEvaTempAnswerDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:964873_1_42368
if(reqDto!=null){
      queryConfItemMatchEvaTempAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:964836_1_42368
    }

    /*D2-3查时段规则设置规则配置[3067]   */
    Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getResultAspObjId(),"D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-评价模板ID不能为空",false);
Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getConfItemCode(),"D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getIsPlatData(),"D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-是否标准答案不能为空",false);
Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto.getSubjectLifeCycle(),"D3-分析时段规则设置(公共)-D2-3查时段规则设置规则配置-主体生命周期不能为空",false);
      queryConfItemMatchEvaTempAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchEvaTempAnswerDetailCom(queryConfItemMatchEvaTempAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchEvaTempAnswerDetailComRespDto!= null&&  queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel() !=null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel().equals("EVA_TEMP_LEVEL"))) {
        //if(D2-3查时段规则设置规则配置.时段规则设置级别 等于 评价模板级)  42371

QueryConfItemMatchEvaTempAnswerDetailComRespDto queryConfItemMatchEvaTempAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchEvaTempAnswerDetailComReqDto queryConfItemMatchEvaTempAnswerDetailComReqDto_1=new QueryConfItemMatchEvaTempAnswerDetailComReqDto();
  queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setConfItemCode("FILL_TIME_RULES_CODE");//CUSTOM_CONVENTION//sourceId:965015_1_42379
queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:965052_1_42379
queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:965053_1_42379
if(reqDto!=null){
      queryConfItemMatchEvaTempAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:965016_1_42379
    }

    /*D2-3查模板填报时段规则标识[3067]   */
    Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getResultAspObjId(),"D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-评价模板ID不能为空",false);
Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getConfItemCode(),"D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getIsPlatData(),"D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-是否标准答案不能为空",false);
Assert.isNull(queryConfItemMatchEvaTempAnswerDetailComReqDto_1.getSubjectLifeCycle(),"D3-分析时段规则设置(公共)-D2-3查模板填报时段规则标识-主体生命周期不能为空",false);
      queryConfItemMatchEvaTempAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchEvaTempAnswerDetailCom(queryConfItemMatchEvaTempAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(queryConfItemMatchEvaTempAnswerDetailComRespDto_2 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(queryConfItemMatchEvaTempAnswerDetailComRespDto_2!=null){
      receptionServiceReq.setCycleConfCode(queryConfItemMatchEvaTempAnswerDetailComRespDto_2.getFillTimeRulesCode());//SimpleFieldAssign//sourceId:965535_1_42386
    }

    /*约定出参：周期配置标识[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleConfCode(),"D3-分析时段规则设置(公共)-约定出参：周期配置标识-周期配置标识不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((queryConfItemMatchEvaTempAnswerDetailComRespDto!= null&&  queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel() !=null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL"))){
       //elseif(D2-3查时段规则设置规则配置.时段规则设置级别 等于 周期类型级)  42373

OmsEvaCycleConf omsEvaCycleConf = null;
    QueryCycleConfDetailReq queryCycleConfDetailReq=new QueryCycleConfDetailReq();
  queryCycleConfDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:964994_1_42380
if(reqDto!=null){
      queryCycleConfDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:964993_1_42380
    }

    /*3-2-08查周期配置详情[2360]   */
    Assert.isNull(queryCycleConfDetailReq.getCycleTypeCode(),"D3-分析时段规则设置(公共)-3-2-08查周期配置详情-周期类型标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq.getSubjectLifeCycle(),"D3-分析时段规则设置(公共)-3-2-08查周期配置详情-主体生命周期不能为空",false);
      omsEvaCycleConf = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(omsEvaCycleConf !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaCycleConf!=null){
      receptionServiceReq_1.setCycleConfCode(omsEvaCycleConf.getCycleConfCode());//SimpleFieldAssign//sourceId:965535_1_42385
    }

    /*约定出参：周期配置标识[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleConfCode(),"D3-分析时段规则设置(公共)-约定出参：周期配置标识-周期配置标识不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else if((queryConfItemMatchEvaTempAnswerDetailComRespDto!= null&&  queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel() !=null && queryConfItemMatchEvaTempAnswerDetailComRespDto.getTimeRulesSetLevel().equals("UNLIMITED"))){
       //elseif(D2-3查时段规则设置规则配置.时段规则设置级别 等于 不限)  42374

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_2.setCycleConfCode("UNLIMITED");//CUSTOM_CONVENTION//sourceId:965685_1_42383

    /*周期配置不限[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCycleConfCode(),"D3-分析时段规则设置(公共)-周期配置不限-周期配置标识不能为空",false);
      receptionServiceRes_3 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_3!=null){
      receptionServiceReq_3.setCycleConfCode(receptionServiceRes_3.getCycleConfCode());//SimpleFieldAssign//sourceId:965535_1_42384
    }

    /*约定出参：周期配置标识[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getCycleConfCode(),"D3-分析时段规则设置(公共)-约定出参：周期配置标识-周期配置标识不能为空",false);
      receptionServiceRes_5 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_1 = receptionServiceRes_5;
    }
ImplementTimeRulesSetLevelComRespDto retData = new ImplementTimeRulesSetLevelComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCycleConfCode(receptionServiceRes_1.getCycleConfCode());//SimpleFieldAssign//sourceId:965694_1
    }




return retData;
  }
/**
   * D3-根据目标周期实际开始结束时间找周期(公共)[6885]
   * gen by moon at 11/9/2023, 10:29:51 PM
   */
  @Trace(operationName = "D3-根据目标周期实际开始结束时间找周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFindExecuteCycleByActualWorkTimeComRespDto implementFindExecuteCycleByActualWorkTimeCom(ImplementFindExecuteCycleByActualWorkTimeComReqDto reqDto){


      OmsCycle omsCycle_1 =null;
Long getDateTimeOrderNumRes_1 = null;
if((reqDto!= null&& reqDto.getTargetActualStartTime() != null )) {
        //if(D3-根据目标周期实际开始结束时间切执行周期(公共).目标实际开始时间 值不等于空 )  42400

OmsCycle omsCycle = null;
    QueryTimeMatchCycleDetailReq queryTimeMatchCycleDetailReq=new QueryTimeMatchCycleDetailReq();
  queryTimeMatchCycleDetailReq.setIsArchive("FALSE");//sourceId:966001_1_42403
if(reqDto!=null){
      queryTimeMatchCycleDetailReq.setCycleStartTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:965997_1_42403
queryTimeMatchCycleDetailReq.setCycleEndTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:965998_1_42403
queryTimeMatchCycleDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:965999_1_42403
queryTimeMatchCycleDetailReq.setPlatformData(reqDto.getPlatformData());//SimpleFieldAssign//sourceId:966000_1_42403
queryTimeMatchCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:966002_1_42403
    }

    /*3-4-04查询时间匹配周期详情（开始小于结束大于）[4985]   */
    Assert.isNull(queryTimeMatchCycleDetailReq.getCycleStartTime(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getCycleEndTime(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getCycleTypeCode(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getPlatformData(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否是平台不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq.getIsArchive(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否存档不能为空",false);
      omsCycle = mOmsCycleService.queryTimeMatchCycleDetail(queryTimeMatchCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsCycle_1 = omsCycle;
//ModelCode: getDateTimeOrderNum
    // TODO: 2023/5/25 手动打码不要合 
    if(omsCycle!=null){
        Long  getDateTimeOrderNumRes=CommonFunctionHelper.getDateTimeOrderNum(reqDto.getTargetActualStartTime(),omsCycle.getCycleEndTime());
        getDateTimeOrderNumRes_1 = getDateTimeOrderNumRes;
    }
        

      }
if((reqDto!= null&& reqDto.getTargetActualEndtTime() != null )) {
        //if(D3-根据目标周期实际开始结束时间切执行周期(公共).目标实际结束时间 值不等于空 )  42402

OmsCycle omsCycle_2 = null;
    QueryTimeMatchCycleDetailReq queryTimeMatchCycleDetailReq_1=new QueryTimeMatchCycleDetailReq();
  queryTimeMatchCycleDetailReq_1.setIsArchive("FALSE");//sourceId:966001_1_42405
if(reqDto!=null){
      queryTimeMatchCycleDetailReq_1.setCycleStartTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:965997_1_42405
queryTimeMatchCycleDetailReq_1.setCycleEndTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:965998_1_42405
queryTimeMatchCycleDetailReq_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:965999_1_42405
queryTimeMatchCycleDetailReq_1.setPlatformData(reqDto.getPlatformData());//SimpleFieldAssign//sourceId:966000_1_42405
queryTimeMatchCycleDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:966002_1_42405
    }

    /*3-4-04查询时间匹配周期详情（开始小于结束大于）[4985]   */
    Assert.isNull(queryTimeMatchCycleDetailReq_1.getCycleStartTime(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq_1.getCycleEndTime(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq_1.getCycleTypeCode(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq_1.getPlatformData(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否是平台不能为空",false);
Assert.isNull(queryTimeMatchCycleDetailReq_1.getIsArchive(),"D3-根据目标周期实际开始结束时间找周期(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否存档不能为空",false);
      omsCycle_2 = mOmsCycleService.queryTimeMatchCycleDetail(queryTimeMatchCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


      omsCycle_1 = omsCycle_2;
//ModelCode: getDateTimeOrderNum
    // TODO: 2023/5/25 手动代码，不要合 
    if(omsCycle_2!=null){
        Long  getDateTimeOrderNumRes_2=CommonFunctionHelper.getDateTimeOrderNum(omsCycle_2.getCycleStartTime(),reqDto.getTargetActualEndtTime());
        getDateTimeOrderNumRes_1 = getDateTimeOrderNumRes_2;
    }
        

      }
ImplementFindExecuteCycleByActualWorkTimeComRespDto retData = new ImplementFindExecuteCycleByActualWorkTimeComRespDto();
  if(omsCycle_1!=null){
      retData.setCycleId(omsCycle_1.getCycleId());//SimpleFieldAssign//sourceId:966041_1
retData.setCycleStandardName(omsCycle_1.getCycleStandardName());//SimpleFieldAssign//sourceId:966042_1
retData.setCycleStartTime(omsCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:966043_1
retData.setCycleEndTime(omsCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:966044_1
retData.setCycleTypeCode(omsCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:966045_1
retData.setCycleTypeInstanceCode(omsCycle_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1604993_1
    }
if(getDateTimeOrderNumRes_1!=null){
    // TODO: 2023/5/23 手写代码
      retData.setOrderNumber(getDateTimeOrderNumRes_1!=null?getDateTimeOrderNumRes_1.longValue():null);//SimpleFieldAssign//sourceId:966046_1
    }




return retData;
  }
/**
   * D3-执行克隆标准过程执行周期(公共)[6896]
   * gen by moon at 5/21/2023, 6:47:12 PM
   */
  @Trace(operationName = "D3-执行克隆标准过程执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCloneStdProExcCycleComRespDto implementCloneStdProExcCycleCom(ImplementCloneStdProExcCycleComReqDto reqDto){


      //virtualUsage M3周期【循环开始】  42505
      //ModelCode: circulationCollections
        for (TargetContPlanWorkTimeDto circulationCollectionsRes: reqDto.getTargetContPlanWorkTimeList()){

//virtualUsage 3-3-09查被评对象目标周期详情  42506
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:969596_1_42506
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:969594_1_42506
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:969595_1_42506
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行克隆标准过程执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行克隆标准过程执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行克隆标准过程执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）  42507
      List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:969857_1_42507
querySubCycleExecuteCycleStageListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:969859_1_42507
if(circulationCollectionsRes!=null){
      querySubCycleExecuteCycleStageListReq.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:969855_1_42507
querySubCycleExecuteCycleStageListReq.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:969856_1_42507
    }
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:969858_1_42507
    }

    /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(),"D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(),"D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(),"D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsProcessCycleStage(),"D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-是否过程周期阶段不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getSubjectLifeCycle(),"D3-执行克隆标准过程执行周期(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-主体生命周期不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-07批量增执行周期阶段  42511
      boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 &&omsEvaluationObjectTargetCycle !=null){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      OmsEvaluationObjectTargetCycle finalOmsEvaluationObjectTargetCycle = omsEvaluationObjectTargetCycle;
      listOmsExecuteCycleStage_2 = //objList-to-objLists
        listOmsExecuteCycleStage.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:206630_2_42511
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:206612_2_42511
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:206636_2_42511
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:206637_2_42511
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:206638_2_42511
elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:206631_2_42511
elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:206632_2_42511
elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:206633_2_42511
elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:206634_2_42511
elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:206613_2_42511
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:206615_2_42511
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:206614_2_42511
elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:206616_2_42511
elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:206617_2_42511
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:206639_2_42511
elm.setCycleTypeConfCode(item.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:206635_2_42511
elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:206620_2_42511
elm.setEvaluationTemplateId(item.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:206621_2_42511
elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:206622_2_42511
elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:206623_2_42511
elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:206624_2_42511
elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:206625_2_42511
elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:206626_2_42511
elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:206627_2_42511
elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:206628_2_42511
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:206629_2_42511
if(circulationCollectionsRes!=null){
      elm.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:206640_2_42511
    }
if(finalOmsEvaluationObjectTargetCycle !=null){
      elm.setRelateContentTypeCode(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:206618_2_42511
elm.setRelateContentId(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:206619_2_42511
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:969521_1_42511
    }

    /*3-3-07批量增执行周期阶段[3151]   */

      bOOLEAN = mOmsExecuteCycleStageService.batchAddExecuteCycleStage(listOmsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage M3-执行【循环结束】  42512
      //ModelCode: circulationEnd
        }

ImplementCloneStdProExcCycleComRespDto retData = new ImplementCloneStdProExcCycleComRespDto();





return retData;
  }
/**
   * D3-执行克隆标准工作执行周期(公共)[6897]
   * gen by moon at 5/22/2023, 11:33:38 PM
   */
  @Trace(operationName = "D3-执行克隆标准工作执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCloneStdWorkExcCycleComRespDto implementCloneStdWorkExcCycleCom(ImplementCloneStdWorkExcCycleComReqDto reqDto){


      //virtualUsage M3周期【循环开始】  42518
      //ModelCode: circulationCollections
        for (TargetContPlanWorkTimeDto circulationCollectionsRes: reqDto.getTargetContPlanWorkTimeList()){

//virtualUsage 3-3-09查被评对象目标周期详情  42524
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:970881_1_42524
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:970879_1_42524
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970880_1_42524
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-07查询执行周期阶段详情  42525
      OmsExecuteCycleStage omsExecuteCycleStage = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:970894_1_42525
if(omsEvaluationObjectTargetCycle!=null){
      queryExecuteCycleStageDetailReq.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:970889_1_42525
queryExecuteCycleStageDetailReq.setIsSubCycle(omsEvaluationObjectTargetCycle.getIsSubCycle());//SimpleFieldAssign//sourceId:970891_1_42525
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42525
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage 3-3-07新增执行周期阶段  42526
      String string = null;
    if(omsExecuteCycleStage !=null&&omsEvaluationObjectTargetCycle !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_2=new OmsExecuteCycleStage();
  omsExecuteCycleStage_2.setIsDefinedExecuteCycleStage("TRUE");//sourceId:970331_1_42526
if(circulationCollectionsRes!=null){
      omsExecuteCycleStage_2.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:970352_1_42526
omsExecuteCycleStage_2.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970346_1_42526
omsExecuteCycleStage_2.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970347_1_42526
omsExecuteCycleStage_2.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970340_1_42526
omsExecuteCycleStage_2.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970341_1_42526
omsExecuteCycleStage_2.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970342_1_42526
omsExecuteCycleStage_2.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970343_1_42526
    }
if(omsExecuteCycleStage!=null){
      omsExecuteCycleStage_2.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:970324_1_42526
omsExecuteCycleStage_2.setCycleStandardName(omsExecuteCycleStage.getCycleStandardName());//SimpleFieldAssign//sourceId:970345_1_42526
omsExecuteCycleStage_2.setCycleTypeCode(omsExecuteCycleStage.getCycleTypeCode());//SimpleFieldAssign//sourceId:970348_1_42526
omsExecuteCycleStage_2.setCycleTypeConfCode(omsExecuteCycleStage.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:970344_1_42526
omsExecuteCycleStage_2.setIsFatherCycle(omsExecuteCycleStage.getIsFatherCycle());//SimpleFieldAssign//sourceId:970327_1_42526
omsExecuteCycleStage_2.setIsSubCycle(omsExecuteCycleStage.getIsSubCycle());//SimpleFieldAssign//sourceId:970328_1_42526
omsExecuteCycleStage_2.setIsMetaphase(omsExecuteCycleStage.getIsMetaphase());//SimpleFieldAssign//sourceId:970329_1_42526
omsExecuteCycleStage_2.setIsProcessCycleStage(omsExecuteCycleStage.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:970330_1_42526
omsExecuteCycleStage_2.setTargetId(omsExecuteCycleStage.getTargetId());//SimpleFieldAssign//sourceId:970339_1_42526
omsExecuteCycleStage_2.setEvaluationTemplateId(omsExecuteCycleStage.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970334_1_42526
omsExecuteCycleStage_2.setIsStartCycle(omsExecuteCycleStage.getIsStartCycle());//SimpleFieldAssign//sourceId:970335_1_42526
omsExecuteCycleStage_2.setIsEndCycle(omsExecuteCycleStage.getIsEndCycle());//SimpleFieldAssign//sourceId:970336_1_42526
omsExecuteCycleStage_2.setIsLastCycle(omsExecuteCycleStage.getIsLastCycle());//SimpleFieldAssign//sourceId:970337_1_42526
omsExecuteCycleStage_2.setEvaTempCreateTime(omsExecuteCycleStage.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:970325_1_42526
omsExecuteCycleStage_2.setOrderNumber(omsExecuteCycleStage.getOrderNumber());//SimpleFieldAssign//sourceId:970326_1_42526
omsExecuteCycleStage_2.setIsCurrentCycle(omsExecuteCycleStage.getIsCurrentCycle());//SimpleFieldAssign//sourceId:970350_1_42526
omsExecuteCycleStage_2.setIsNextCycle(omsExecuteCycleStage.getIsNextCycle());//SimpleFieldAssign//sourceId:970351_1_42526
omsExecuteCycleStage_2.setNextCyclePeriod(omsExecuteCycleStage.getNextCyclePeriod());//SimpleFieldAssign//sourceId:970353_1_42526
    }
if(omsEvaluationObjectTargetCycle!=null){
      omsExecuteCycleStage_2.setRelateContentTypeCode(omsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:970332_1_42526
omsExecuteCycleStage_2.setRelateContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:970333_1_42526
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage_2.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleStandardName(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleStartTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleEndTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getFillStartTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getFillEndtTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleTypeCode(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsFatherCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsSubCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsMetaphase(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsProcessCycleStage(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsDefinedExecuteCycleStage(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getRelateContentTypeCode(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getRelateContentId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getTargetId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsStartCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否开始周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsEndCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否截止周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsLastCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaTempCreateTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getOrderNumber(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-排序不能为空",false);
      string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage M3-执行【循环结束】  42519
      //ModelCode: circulationEnd
        }

if((reqDto!= null&& reqDto.getTargetCycleParentCycleId() != null )) {
        //if(D3-执行克隆标准工作执行周期(公共).目标周期父周期ID 值不等于空 )  42527

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:970881_1_42530
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:970879_1_42530
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970880_1_42530
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
    QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq=new QueryTargetCyclePsetDetailReq();
  if(reqDto!=null){
      queryTargetCyclePsetDetailReq.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:971183_1_42554
queryTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971177_1_42554
    }

    /*3-3-08查询目标周期规划设置详情[3368]   */
    Assert.isNull(queryTargetCyclePsetDetailReq.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-冗余评价模板ID不能为空",false);
      omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



OmsExecuteCycleStage omsExecuteCycleStage_3 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:970894_1_42551
if(omsEvaluationObjectTargetCycle_2!=null){
      queryExecuteCycleStageDetailReq_1.setCycleId(omsEvaluationObjectTargetCycle_2.getCycleId());//SimpleFieldAssign//sourceId:970889_1_42551
queryExecuteCycleStageDetailReq_1.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_2.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:971280_1_42551
queryExecuteCycleStageDetailReq_1.setRelateContentId(omsEvaluationObjectTargetCycle_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:971281_1_42551
queryExecuteCycleStageDetailReq_1.setIsFatherCycle(omsEvaluationObjectTargetCycle_2.getIsParentCycle());//SimpleFieldAssign//sourceId:970890_1_42551
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42551
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage_3 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
if((omsExecuteCycleStage_3 == null )) {
        //if(3-3-07查是否已存在内容父周期执行周期.出参 值等于空 )  42552

OmsExecuteCycleStage omsExecuteCycleStage_4 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_2=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_2.setIsArchive("FALSE");//sourceId:970894_1_42555
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_2.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971281_1_42555
queryExecuteCycleStageDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42555
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      queryExecuteCycleStageDetailReq_2.setIsFatherCycle(omsEvaluationObjectTargetCycle_2.getIsParentCycle());//SimpleFieldAssign//sourceId:970890_1_42555
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_2.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_2.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage_4 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
String string_2 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null&&omsTargetCyclePlanSet !=null&&omsExecuteCycleStage_4 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_5=new OmsExecuteCycleStage();
  omsExecuteCycleStage_5.setIsDefinedExecuteCycleStage("TRUE");//sourceId:970331_1_42556
if(reqDto!=null){
      omsExecuteCycleStage_5.setEvaObjTargetCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:970352_1_42556
omsExecuteCycleStage_5.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970334_1_42556
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      omsExecuteCycleStage_5.setCycleId(omsEvaluationObjectTargetCycle_2.getCycleId());//SimpleFieldAssign//sourceId:970324_1_42556
omsExecuteCycleStage_5.setCycleStandardName(omsEvaluationObjectTargetCycle_2.getCycleStandardName());//SimpleFieldAssign//sourceId:970345_1_42556
omsExecuteCycleStage_5.setCycleTypeCode(omsEvaluationObjectTargetCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:970348_1_42556
omsExecuteCycleStage_5.setIsFatherCycle(omsEvaluationObjectTargetCycle_2.getIsParentCycle());//SimpleFieldAssign//sourceId:970327_1_42556
omsExecuteCycleStage_5.setIsSubCycle(omsEvaluationObjectTargetCycle_2.getIsSubCycle());//SimpleFieldAssign//sourceId:970328_1_42556
omsExecuteCycleStage_5.setIsMetaphase(omsEvaluationObjectTargetCycle_2.getIsMetaphase());//SimpleFieldAssign//sourceId:970329_1_42556
omsExecuteCycleStage_5.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_2.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:970332_1_42556
omsExecuteCycleStage_5.setRelateContentId(omsEvaluationObjectTargetCycle_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:970333_1_42556
omsExecuteCycleStage_5.setOrderNumber(omsEvaluationObjectTargetCycle_2.getOrderNumber());//SimpleFieldAssign//sourceId:970326_1_42556
    }
if(omsTargetCyclePlanSet!=null){
      omsExecuteCycleStage_5.setCycleStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970346_1_42556
omsExecuteCycleStage_5.setCycleEndTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970347_1_42556
omsExecuteCycleStage_5.setFillStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970340_1_42556
omsExecuteCycleStage_5.setFillEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970341_1_42556
omsExecuteCycleStage_5.setEvaluateStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970342_1_42556
omsExecuteCycleStage_5.setEvaluateEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970343_1_42556
    }
if(omsExecuteCycleStage_4!=null){
      omsExecuteCycleStage_5.setCycleTypeConfCode(omsExecuteCycleStage_4.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:970344_1_42556
omsExecuteCycleStage_5.setIsProcessCycleStage(omsExecuteCycleStage_4.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:970330_1_42556
omsExecuteCycleStage_5.setTargetId(omsExecuteCycleStage_4.getTargetId());//SimpleFieldAssign//sourceId:970339_1_42556
omsExecuteCycleStage_5.setIsStartCycle(omsExecuteCycleStage_4.getIsStartCycle());//SimpleFieldAssign//sourceId:970335_1_42556
omsExecuteCycleStage_5.setIsEndCycle(omsExecuteCycleStage_4.getIsEndCycle());//SimpleFieldAssign//sourceId:970336_1_42556
omsExecuteCycleStage_5.setIsLastCycle(omsExecuteCycleStage_4.getIsLastCycle());//SimpleFieldAssign//sourceId:970337_1_42556
omsExecuteCycleStage_5.setEvaTempCreateTime(omsExecuteCycleStage_4.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:970325_1_42556
omsExecuteCycleStage_5.setIsCurrentCycle(omsExecuteCycleStage_4.getIsCurrentCycle());//SimpleFieldAssign//sourceId:970350_1_42556
omsExecuteCycleStage_5.setIsNextCycle(omsExecuteCycleStage_4.getIsNextCycle());//SimpleFieldAssign//sourceId:970351_1_42556
omsExecuteCycleStage_5.setNextCyclePeriod(omsExecuteCycleStage_4.getNextCyclePeriod());//SimpleFieldAssign//sourceId:970353_1_42556
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage_5.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getCycleStandardName(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getCycleStartTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getCycleEndTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getFillStartTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getFillEndtTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getCycleTypeCode(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsFatherCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsSubCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsMetaphase(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsProcessCycleStage(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsDefinedExecuteCycleStage(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getRelateContentTypeCode(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getRelateContentId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getTargetId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsStartCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否开始周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsEndCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否截止周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsLastCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getEvaTempCreateTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getOrderNumber(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-排序不能为空",false);
      string_2 = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_5)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((omsExecuteCycleStage_3 != null )){
       //elseif(3-3-07查是否已存在内容父周期执行周期.出参 值不等于空 )  42553

boolean bOOLEAN ;
    if(omsExecuteCycleStage_3 !=null&&omsTargetCyclePlanSet !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_6=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage_3!=null){
      omsExecuteCycleStage_6.setExecuteCycleStageId(omsExecuteCycleStage_3.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:971317_1_42558
    }
if(omsTargetCyclePlanSet!=null){
      omsExecuteCycleStage_6.setCycleStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971319_1_42558
omsExecuteCycleStage_6.setCycleEndTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971318_1_42558
omsExecuteCycleStage_6.setFillStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971320_1_42558
omsExecuteCycleStage_6.setFillEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971321_1_42558
omsExecuteCycleStage_6.setEvaluateStartTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971322_1_42558
omsExecuteCycleStage_6.setEvaluateEndtTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971323_1_42558
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_6.getExecuteCycleStageId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
      bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_6)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
      }
if((reqDto!= null&& reqDto.getTargetCycleMidCycleId() != null )) {
        //if(D3-执行克隆标准工作执行周期(公共). 目标周期中期ID 值不等于空 )  42529

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:970881_1_42533
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_2.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:970879_1_42533
queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970880_1_42533
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_3 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



OmsTargetCyclePlanSet omsTargetCyclePlanSet_2 = null;
    QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq_1=new QueryTargetCyclePsetDetailReq();
  if(reqDto!=null){
      queryTargetCyclePsetDetailReq_1.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:971183_1_42549
queryTargetCyclePsetDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971177_1_42549
    }

    /*3-3-08查询目标周期规划设置详情[3368]   */
    Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq_1.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-08查询目标周期规划设置详情-冗余评价模板ID不能为空",false);
      omsTargetCyclePlanSet_2 = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



OmsExecuteCycleStage omsExecuteCycleStage_7 = null;
    if(omsEvaluationObjectTargetCycle_3 !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_3=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_3.setIsArchive("FALSE");//sourceId:970894_1_42535
if(omsEvaluationObjectTargetCycle_3!=null){
      queryExecuteCycleStageDetailReq_3.setCycleId(omsEvaluationObjectTargetCycle_3.getCycleId());//SimpleFieldAssign//sourceId:970889_1_42535
queryExecuteCycleStageDetailReq_3.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_3.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:971280_1_42535
queryExecuteCycleStageDetailReq_3.setRelateContentId(omsEvaluationObjectTargetCycle_3.getTargetCycleContentId());//SimpleFieldAssign//sourceId:971281_1_42535
queryExecuteCycleStageDetailReq_3.setIsMetaphase(omsEvaluationObjectTargetCycle_3.getIsMetaphase());//SimpleFieldAssign//sourceId:970892_1_42535
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42535
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_3.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_3.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage_7 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
if((omsExecuteCycleStage_7 == null )) {
        //if(3-3-07查是否已存在内容中期执行周期.出参 值等于空 )  42560

OmsExecuteCycleStage omsExecuteCycleStage_8 = null;
    if(omsEvaluationObjectTargetCycle_3 !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_4=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_4.setIsArchive("FALSE");//sourceId:970894_1_42561
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_4.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971281_1_42561
      queryExecuteCycleStageDetailReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970893_1_42561
    }
if(omsEvaluationObjectTargetCycle_3!=null){
      queryExecuteCycleStageDetailReq_4.setIsMetaphase(omsEvaluationObjectTargetCycle_3.getIsMetaphase());//SimpleFieldAssign//sourceId:970892_1_42561
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_4.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_4.getIsArchive(),"D3-执行克隆标准工作执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage_8 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;



           }
String string_3 = null;
    if(omsEvaluationObjectTargetCycle_3 !=null&&omsTargetCyclePlanSet_2 !=null&&omsExecuteCycleStage_8 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_9=new OmsExecuteCycleStage();
  omsExecuteCycleStage_9.setIsDefinedExecuteCycleStage("TRUE");//sourceId:970331_1_42562
if(reqDto!=null){
      omsExecuteCycleStage_9.setEvaObjTargetCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:970352_1_42562
omsExecuteCycleStage_9.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:970334_1_42562
    }
if(omsEvaluationObjectTargetCycle_3!=null){
      omsExecuteCycleStage_9.setCycleId(omsEvaluationObjectTargetCycle_3.getCycleId());//SimpleFieldAssign//sourceId:970324_1_42562
omsExecuteCycleStage_9.setCycleStandardName(omsEvaluationObjectTargetCycle_3.getCycleStandardName());//SimpleFieldAssign//sourceId:970345_1_42562
omsExecuteCycleStage_9.setCycleTypeCode(omsEvaluationObjectTargetCycle_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:970348_1_42562
omsExecuteCycleStage_9.setIsFatherCycle(omsEvaluationObjectTargetCycle_3.getIsParentCycle());//SimpleFieldAssign//sourceId:970327_1_42562
omsExecuteCycleStage_9.setIsSubCycle(omsEvaluationObjectTargetCycle_3.getIsSubCycle());//SimpleFieldAssign//sourceId:970328_1_42562
omsExecuteCycleStage_9.setIsMetaphase(omsEvaluationObjectTargetCycle_3.getIsMetaphase());//SimpleFieldAssign//sourceId:970329_1_42562
omsExecuteCycleStage_9.setRelateContentTypeCode(omsEvaluationObjectTargetCycle_3.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:970332_1_42562
omsExecuteCycleStage_9.setRelateContentId(omsEvaluationObjectTargetCycle_3.getTargetCycleContentId());//SimpleFieldAssign//sourceId:970333_1_42562
omsExecuteCycleStage_9.setOrderNumber(omsEvaluationObjectTargetCycle_3.getOrderNumber());//SimpleFieldAssign//sourceId:970326_1_42562
    }
if(omsTargetCyclePlanSet_2!=null){
      omsExecuteCycleStage_9.setCycleStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970346_1_42562
omsExecuteCycleStage_9.setCycleEndTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970347_1_42562
omsExecuteCycleStage_9.setFillStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970340_1_42562
omsExecuteCycleStage_9.setFillEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970341_1_42562
omsExecuteCycleStage_9.setEvaluateStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:970342_1_42562
omsExecuteCycleStage_9.setEvaluateEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:970343_1_42562
    }
if(omsExecuteCycleStage_8!=null){
      omsExecuteCycleStage_9.setCycleTypeConfCode(omsExecuteCycleStage_8.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:970344_1_42562
omsExecuteCycleStage_9.setIsProcessCycleStage(omsExecuteCycleStage_8.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:970330_1_42562
omsExecuteCycleStage_9.setTargetId(omsExecuteCycleStage_8.getTargetId());//SimpleFieldAssign//sourceId:970339_1_42562
omsExecuteCycleStage_9.setIsStartCycle(omsExecuteCycleStage_8.getIsStartCycle());//SimpleFieldAssign//sourceId:970335_1_42562
omsExecuteCycleStage_9.setIsEndCycle(omsExecuteCycleStage_8.getIsEndCycle());//SimpleFieldAssign//sourceId:970336_1_42562
omsExecuteCycleStage_9.setIsLastCycle(omsExecuteCycleStage_8.getIsLastCycle());//SimpleFieldAssign//sourceId:970337_1_42562
omsExecuteCycleStage_9.setEvaTempCreateTime(omsExecuteCycleStage_8.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:970325_1_42562
omsExecuteCycleStage_9.setIsCurrentCycle(omsExecuteCycleStage_8.getIsCurrentCycle());//SimpleFieldAssign//sourceId:970350_1_42562
omsExecuteCycleStage_9.setIsNextCycle(omsExecuteCycleStage_8.getIsNextCycle());//SimpleFieldAssign//sourceId:970351_1_42562
omsExecuteCycleStage_9.setNextCyclePeriod(omsExecuteCycleStage_8.getNextCyclePeriod());//SimpleFieldAssign//sourceId:970353_1_42562
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage_9.getEvaObjTargetCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getCycleId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getCycleStandardName(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getCycleStartTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getCycleEndTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getFillStartTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getFillEndtTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getCycleTypeCode(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsFatherCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsSubCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsMetaphase(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsProcessCycleStage(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsDefinedExecuteCycleStage(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getRelateContentTypeCode(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getRelateContentId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getTargetId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getEvaluationTemplateId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsStartCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否开始周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsEndCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否截止周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getIsLastCycle(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getEvaTempCreateTime(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_9.getOrderNumber(),"D3-执行克隆标准工作执行周期(公共)-3-3-07新增执行周期阶段-排序不能为空",false);
      string_3 = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_9)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((omsExecuteCycleStage_7 != null )){
       //elseif(3-3-07查是否已存在内容中期执行周期.出参 值不等于空 )  42563

boolean bOOLEAN_1 ;
    if(omsExecuteCycleStage_7 !=null&&omsTargetCyclePlanSet_2 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_10=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage_7!=null){
      omsExecuteCycleStage_10.setExecuteCycleStageId(omsExecuteCycleStage_7.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:971317_1_42564
    }
if(omsTargetCyclePlanSet_2!=null){
      omsExecuteCycleStage_10.setCycleStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971319_1_42564
omsExecuteCycleStage_10.setCycleEndTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971318_1_42564
omsExecuteCycleStage_10.setFillStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971320_1_42564
omsExecuteCycleStage_10.setFillEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971321_1_42564
omsExecuteCycleStage_10.setEvaluateStartTime(omsTargetCyclePlanSet_2.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971322_1_42564
omsExecuteCycleStage_10.setEvaluateEndtTime(omsTargetCyclePlanSet_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971323_1_42564
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_10.getExecuteCycleStageId(),"D3-执行克隆标准工作执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
      bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_10)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
      }
ImplementCloneStdWorkExcCycleComRespDto retData = new ImplementCloneStdWorkExcCycleComRespDto();





return retData;
  }
/**
   * D3-执行补偿克隆过程执行周期(公共)[6898]
   * gen by moon at 5/21/2023, 10:18:35 PM
   */
  @Trace(operationName = "D3-执行补偿克隆过程执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCompCloneProExcCycleComRespDto implementCompCloneProExcCycleCom(ImplementCompCloneProExcCycleComReqDto reqDto){


      //virtualUsage M3周期【循环开始】  42570
      //ModelCode: circulationCollections
        for (TargetContPlanWorkTimeDto circulationCollectionsRes: reqDto.getTargetContPlanWorkTimeList()){

//virtualUsage 3-3-09查被评对象目标周期详情  42599
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:972315_1_42599
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:972313_1_42599
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972314_1_42599
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行补偿克隆过程执行周期(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行补偿克隆过程执行周期(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3-执行补偿克隆过程执行周期(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-7查询执行周期列表（开始时间小于&结束时间大于）  42583
      List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleSmallStartListReq queryExecuteCycleSmallStartListReq=new QueryExecuteCycleSmallStartListReq();
  queryExecuteCycleSmallStartListReq.setIsProcessCycleStage("TRUE");//sourceId:971946_1_42583
if(circulationCollectionsRes!=null){
      queryExecuteCycleSmallStartListReq.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971939_1_42583
queryExecuteCycleSmallStartListReq.setCycleEndTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:971940_1_42583
    }
if(reqDto!=null){
      queryExecuteCycleSmallStartListReq.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971991_1_42583
queryExecuteCycleSmallStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971949_1_42583
    }

    /*3-3-7查询执行周期列表（开始时间小于&结束时间大于）[6900]   */
    Assert.isNull(queryExecuteCycleSmallStartListReq.getCycleStartTime(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq.getCycleEndTime(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq.getIsProcessCycleStage(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq.getRelateContentId(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq.getEvaluationTemplateId(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleSmallStartList(queryExecuteCycleSmallStartListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage!= null&&  listOmsExecuteCycleStage !=null && listOmsExecuteCycleStage.size()>0)) {
        //if(3-3-7查开始时间匹配的执行周期列表.执行周期阶段列表数据集条数 大于 0)  42592

boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 &&omsEvaluationObjectTargetCycle !=null){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      OmsEvaluationObjectTargetCycle finalOmsEvaluationObjectTargetCycle = omsEvaluationObjectTargetCycle;
      listOmsExecuteCycleStage_2 = //objList-to-objLists
        listOmsExecuteCycleStage.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:207304_2_42595
elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:207293_2_42595
elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:207303_2_42595
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:207275_2_42595
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:207299_2_42595
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:207301_2_42595
elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:207295_2_42595
elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:207297_2_42595
elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:207276_2_42595
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:207277_2_42595
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:207278_2_42595
elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:207279_2_42595
elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:207280_2_42595
elm.setCycleTypeConfCode(item.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:207298_2_42595
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:207302_2_42595
elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:207283_2_42595
elm.setEvaluationTemplateId(item.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:207284_2_42595
elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:207285_2_42595
elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:207286_2_42595
elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:207287_2_42595
elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:207288_2_42595
elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:207289_2_42595
elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:207290_2_42595
elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:207291_2_42595
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:207292_2_42595
if(circulationCollectionsRes!=null){
      elm.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207300_2_42595
elm.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207294_2_42595
elm.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207296_2_42595
    }
if(finalOmsEvaluationObjectTargetCycle !=null){
      elm.setRelateContentTypeCode(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207281_2_42595
elm.setRelateContentId(finalOmsEvaluationObjectTargetCycle.getTargetCycleContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207282_2_42595
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:972057_1_42595
    }

    /*3-3-07批量增执行周期阶段[3151]   */

      bOOLEAN = mOmsExecuteCycleStageService.batchAddExecuteCycleStage(listOmsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
//virtualUsage 3-3-7查询执行周期列表（开始时间小于&结束时间大于）  42596
      List<OmsExecuteCycleStage> listOmsExecuteCycleStage_3 =new ArrayList<>();
    QueryExecuteCycleSmallStartListReq queryExecuteCycleSmallStartListReq_1=new QueryExecuteCycleSmallStartListReq();
  queryExecuteCycleSmallStartListReq_1.setIsProcessCycleStage("TRUE");//sourceId:971946_1_42596
if(circulationCollectionsRes!=null){
      queryExecuteCycleSmallStartListReq_1.setCycleStartTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971939_1_42596
queryExecuteCycleSmallStartListReq_1.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:971940_1_42596
    }
if(reqDto!=null){
      queryExecuteCycleSmallStartListReq_1.setRelateContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:971991_1_42596
queryExecuteCycleSmallStartListReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:971949_1_42596
    }

    /*3-3-7查询执行周期列表（开始时间小于&结束时间大于）[6900]   */
    Assert.isNull(queryExecuteCycleSmallStartListReq_1.getCycleStartTime(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq_1.getCycleEndTime(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq_1.getIsProcessCycleStage(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq_1.getRelateContentId(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleSmallStartListReq_1.getEvaluationTemplateId(),"D3-执行补偿克隆过程执行周期(公共)-3-3-7查询执行周期列表（开始时间小于&结束时间大于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_3 = mOmsExecuteCycleStageService.queryExecuteCycleSmallStartList(queryExecuteCycleSmallStartListReq_1)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage_3!= null&&  listOmsExecuteCycleStage_3 !=null && listOmsExecuteCycleStage_3.size()>0)) {
        //if(3-3-7查结束时间匹配的执行周期列表.执行周期阶段列表数据集条数 大于 0)  42597

boolean bOOLEAN_1 ;
    if(listOmsExecuteCycleStage_3 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_3)&& listOmsExecuteCycleStage_3.size()>0 &&omsEvaluationObjectTargetCycle !=null){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4=new ArrayList<>();
  if(listOmsExecuteCycleStage_3!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_3)&&  listOmsExecuteCycleStage_3 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_3)){
      OmsEvaluationObjectTargetCycle finalOmsEvaluationObjectTargetCycle1 = omsEvaluationObjectTargetCycle;
      listOmsExecuteCycleStage_4 = //objList-to-objLists
        listOmsExecuteCycleStage_3.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:207304_2_42598
elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:207293_2_42598
elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:207303_2_42598
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:207275_2_42598
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:207299_2_42598
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:207300_2_42598
elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:207294_2_42598
elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:207296_2_42598
elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:207276_2_42598
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:207277_2_42598
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:207278_2_42598
elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:207279_2_42598
elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:207280_2_42598
elm.setCycleTypeConfCode(item.getCycleTypeConfCode());//SimpleFieldAssign//sourceId:207298_2_42598
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:207302_2_42598
elm.setTargetId(item.getTargetId());//SimpleFieldAssign//sourceId:207283_2_42598
elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:207285_2_42598
elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:207286_2_42598
elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:207287_2_42598
elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:207288_2_42598
elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:207289_2_42598
elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:207290_2_42598
elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:207291_2_42598
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:207292_2_42598
if(circulationCollectionsRes!=null){
      elm.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207301_2_42598
elm.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207295_2_42598
elm.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207297_2_42598
    }
if(finalOmsEvaluationObjectTargetCycle1 !=null){
      elm.setRelateContentTypeCode(finalOmsEvaluationObjectTargetCycle1.getTargetCycleContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207281_2_42598
elm.setRelateContentId(finalOmsEvaluationObjectTargetCycle1.getTargetCycleContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207282_2_42598
    }
if(reqDto!=null){
      elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:207284_2_42598
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:972057_1_42598
    }

    /*3-3-07批量增执行周期阶段[3151]   */

      bOOLEAN_1 = mOmsExecuteCycleStageService.batchAddExecuteCycleStage(listOmsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
//virtualUsage M3-执行【循环结束】  42571
      //ModelCode: circulationEnd
        }

ImplementCompCloneProExcCycleComRespDto retData = new ImplementCompCloneProExcCycleComRespDto();





return retData;
  }
/**
   * D3-执行自定义汇报克隆标准执行周期(公共)[6895]
   * gen by moon at 5/21/2023, 10:18:52 PM
   */
  @Trace(operationName = "D3-执行自定义汇报克隆标准执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCustomizeReportCloneStdExcCycleComRespDto implementCustomizeReportCloneStdExcCycleCom(ImplementCustomizeReportCloneStdExcCycleComReqDto reqDto){


      //virtualUsage D3-执行克隆标准过程执行周期(公共)  42588
      ImplementCloneStdProExcCycleComRespDto implementCloneStdProExcCycleComRespDto = null;
    ImplementCloneStdProExcCycleComReqDto implementCloneStdProExcCycleComReqDto=new ImplementCloneStdProExcCycleComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      implementCloneStdProExcCycleComReqDto.setTargetContPlanWorkTimeList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972013_1_42588
    }
if(reqDto!=null){
      implementCloneStdProExcCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972014_1_42588
    }

    /*D3-执行克隆标准过程执行周期(公共)[6896]   */
    Assert.isNull(implementCloneStdProExcCycleComReqDto.getEvaluationTemplateId(),"D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行克隆标准过程执行周期(公共)-冗余评价模板ID不能为空",false);
      implementCloneStdProExcCycleComRespDto = implementCloneStdProExcCycleCom(implementCloneStdProExcCycleComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D3-执行克隆标准工作执行周期(公共)  42589
      ImplementCloneStdWorkExcCycleComRespDto implementCloneStdWorkExcCycleComRespDto = null;
    ImplementCloneStdWorkExcCycleComReqDto implementCloneStdWorkExcCycleComReqDto=new ImplementCloneStdWorkExcCycleComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      implementCloneStdWorkExcCycleComReqDto.setTargetContPlanWorkTimeList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972015_1_42589
    }
if(reqDto!=null){
      implementCloneStdWorkExcCycleComReqDto.setTargetCycleParentCycleId(reqDto.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:972016_1_42589
implementCloneStdWorkExcCycleComReqDto.setTargetCycleMidCycleId(reqDto.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:972018_1_42589
implementCloneStdWorkExcCycleComReqDto.setCustomField1(reqDto.getCustomField1());//SimpleFieldAssign//sourceId:972017_1_42589
implementCloneStdWorkExcCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:972431_1_42589
implementCloneStdWorkExcCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972019_1_42589
    }

    /*D3-执行克隆标准工作执行周期(公共)[6897]   */
    Assert.isNull(implementCloneStdWorkExcCycleComReqDto.getTargetId(),"D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行克隆标准工作执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementCloneStdWorkExcCycleComReqDto.getEvaluationTemplateId(),"D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行克隆标准工作执行周期(公共)-冗余评价模板ID不能为空",false);
      implementCloneStdWorkExcCycleComRespDto = implementCloneStdWorkExcCycleCom(implementCloneStdWorkExcCycleComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage D3-执行补偿克隆过程执行周期(公共)  42591
      ImplementCompCloneProExcCycleComRespDto implementCompCloneProExcCycleComRespDto = null;
    ImplementCompCloneProExcCycleComReqDto implementCompCloneProExcCycleComReqDto=new ImplementCompCloneProExcCycleComReqDto();
  if(reqDto!= null&&  reqDto.getTargetContPlanWorkTimeList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetContPlanWorkTimeList())){
      implementCompCloneProExcCycleComReqDto.setTargetContPlanWorkTimeList(reqDto.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972020_1_42591
    }
if(reqDto!=null){
      implementCompCloneProExcCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:972022_1_42591
implementCompCloneProExcCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972021_1_42591
    }

    /*D3-执行补偿克隆过程执行周期(公共)[6898]   */
    Assert.isNull(implementCompCloneProExcCycleComReqDto.getTargetId(),"D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行补偿克隆过程执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementCompCloneProExcCycleComReqDto.getEvaluationTemplateId(),"D3-执行自定义汇报克隆标准执行周期(公共)-D3-执行补偿克隆过程执行周期(公共)-冗余评价模板ID不能为空",false);
      implementCompCloneProExcCycleComRespDto = implementCompCloneProExcCycleCom(implementCompCloneProExcCycleComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementCustomizeReportCloneStdExcCycleComRespDto retData = new ImplementCustomizeReportCloneStdExcCycleComRespDto();





return retData;
  }
/**
   * D3-获取执行周期时段规则(公共)[6903]
   * gen by moon at 7/6/2024, 11:57:07 PM
   */
  @Trace(operationName = "D3-获取执行周期时段规则(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainExecuteCycleTimeRuleComRespDto obtainExecuteCycleTimeRuleCom(ObtainExecuteCycleTimeRuleComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 =null;
//virtualUsage M3-约定字段：是否  71368
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("TRUE");//CUSTOM_CONVENTION//sourceId:1923319_1_71368
receptionServiceReq.setCustomField2("FALSE");//CUSTOM_CONVENTION//sourceId:1923320_1_71368

    /*M3-约定字段：是否[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3-获取执行周期时段规则(公共)-M3-约定字段：是否-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3-获取执行周期时段规则(公共)-M3-约定字段：是否-自定义字段2不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getTimeRulesSetLevel() !=null && reqDto.getTimeRulesSetLevel().equals("EVA_TEMP_LEVEL"))) {
        //if(D3-获取执行周期时段规则(公共).时段规则设置级别 等于 评价模板级)  42606

ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto = null;
    ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto=new ObtainCycleTimeRuleInfoComReqDto();
  if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      obtainCycleTimeRuleInfoComReqDto.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_68148
    }
if(reqDto!=null){
      obtainCycleTimeRuleInfoComReqDto.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_68148
obtainCycleTimeRuleInfoComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_68148
obtainCycleTimeRuleInfoComReqDto.setTimeRuleCode(reqDto.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_68148
obtainCycleTimeRuleInfoComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784922_1_68148
obtainCycleTimeRuleInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_68148
    }

    /*D3-2时段规则分析4个时间点(公共)[3519]   */
    Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getExecuteCycleStageId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getCycleId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getTimeRuleCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto.getEvaluationTemplateId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空",false);
      obtainCycleTimeRuleInfoComRespDto = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(obtainCycleTimeRuleInfoComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(obtainCycleTimeRuleInfoComRespDto!=null){
      receptionServiceReq_1.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_42614
receptionServiceReq_1.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_42614
receptionServiceReq_1.setComTimeField1(obtainCycleTimeRuleInfoComRespDto.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_42614
receptionServiceReq_1.setComTimeField2(obtainCycleTimeRuleInfoComRespDto.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_42614
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTimePeriodStartTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getTimePeriodEndTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((reqDto!= null&&  reqDto.getTimeRulesSetLevel() !=null && reqDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL")&&reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))){
       //elseif((D3-获取执行周期时段规则(公共).时段规则设置级别 等于 周期类型级 and D3-获取执行周期时段规则(公共).关联目标内容类型编码 等于 目标))  42608

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1784944_1_68149
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1784935_1_68149
queryConfItemMatchAnswerDetailComReqDto.setConfOptionCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784938_1_68149
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto.setIsPlatData(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1784933_1_68149
    }

    /*D2-3查周期类型的周期配置标识[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeId(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置方案ID 不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfOptionCode(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-选项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&& queryConfItemMatchAnswerDetailComRespDto.getExtensionField2() == null )) {
        //if(D2-3查当前周期类型的周期配置标识.扩展字段2（非必填） 值等于空 )  71350

//异常结束 71351
      throw new BizException("220200406","对不起，周期类型的周期配置未设置~",false);
      }
OmsEvaCycleConf omsEvaCycleConf = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          QueryCycleConfDetailReq queryCycleConfDetailReq=new QueryCycleConfDetailReq();
  queryCycleConfDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1785050_1_68150
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      queryCycleConfDetailReq.setCycleConfCode(queryConfItemMatchAnswerDetailComRespDto.getExtensionField2());//SimpleFieldAssign//sourceId:1785048_1_68150
    }
if(reqDto!=null){
      queryCycleConfDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1785076_1_68150
    }

    /*3-2-08查周期配置详情[2360]   */
    Assert.isNull(queryCycleConfDetailReq.getCycleConfCode(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期配置标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期类型标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq.getSubjectLifeCycle(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-主体生命周期不能为空",false);
      omsEvaCycleConf = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaCycleConf== null||  omsEvaCycleConf.getFillinTimeRuleCode() ==null,"找不到数据，系统异常",false);


           }
ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto_2 = null;
    if(omsEvaCycleConf !=null){
          ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto_1=new ObtainCycleTimeRuleInfoComReqDto();
  if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      obtainCycleTimeRuleInfoComReqDto_1.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_42609
    }
if(reqDto!=null){
      obtainCycleTimeRuleInfoComReqDto_1.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_42609
obtainCycleTimeRuleInfoComReqDto_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_42609
obtainCycleTimeRuleInfoComReqDto_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784922_1_42609
obtainCycleTimeRuleInfoComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_42609
    }
if(omsEvaCycleConf!=null){
      obtainCycleTimeRuleInfoComReqDto_1.setTimeRuleCode(omsEvaCycleConf.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_42609
    }

    /*D3-2时段规则分析4个时间点(公共)[3519]   */
    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getExecuteCycleStageId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getCycleId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getTimeRuleCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_1.getEvaluationTemplateId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空",false);
      obtainCycleTimeRuleInfoComRespDto_2 = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto_1)/*vcase invoke isSameApp*/;



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    if(obtainCycleTimeRuleInfoComRespDto_2 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(obtainCycleTimeRuleInfoComRespDto_2!=null){
      receptionServiceReq_2.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto_2.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_42613
receptionServiceReq_2.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto_2.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_42613
receptionServiceReq_2.setComTimeField1(obtainCycleTimeRuleInfoComRespDto_2.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_42613
receptionServiceReq_2.setComTimeField2(obtainCycleTimeRuleInfoComRespDto_2.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_42613
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTimePeriodStartTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空",false);
Assert.isNull(receptionServiceReq_2.getTimePeriodEndTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空",false);
      receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
    }
else if((reqDto!= null&&  reqDto.getTimeRulesSetLevel() !=null && reqDto.getTimeRulesSetLevel().equals("CYCLE_TYPE_LEVEL"))&&(reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-获取执行周期时段规则(公共).时段规则设置级别 等于 周期类型级 and (D3-获取执行周期时段规则(公共).关联目标内容类型编码 等于 目标分类 or D3-获取执行周期时段规则(公共).关联目标内容类型编码 等于 指标))  71349

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1784944_1_71352
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1784935_1_71352
queryConfItemMatchAnswerDetailComReqDto_1.setConfOptionCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784938_1_71352
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1784933_1_71352
    }

    /*D2-3查周期类型的周期配置标识[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfSchemeId(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置方案ID 不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfOptionCode(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-选项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto_2!= null&& queryConfItemMatchAnswerDetailComRespDto_2.getExtensionField2() != null )) {
        //if(D2-3查当前周期类型的周期配置标识.扩展字段2（非必填） 值不等于空 )  71353

OmsEvaCycleConf omsEvaCycleConf_2 = null;
    if(queryConfItemMatchAnswerDetailComRespDto_2 !=null){
          QueryCycleConfDetailReq queryCycleConfDetailReq_1=new QueryCycleConfDetailReq();
  queryCycleConfDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1785050_1_71354
if(queryConfItemMatchAnswerDetailComRespDto_2!=null){
      queryCycleConfDetailReq_1.setCycleConfCode(queryConfItemMatchAnswerDetailComRespDto_2.getExtensionField2());//SimpleFieldAssign//sourceId:1785048_1_71354
    }
if(reqDto!=null){
      queryCycleConfDetailReq_1.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1785076_1_71354
    }

    /*3-2-08查周期配置详情[2360]   */
    Assert.isNull(queryCycleConfDetailReq_1.getCycleConfCode(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期配置标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq_1.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期类型标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq_1.getSubjectLifeCycle(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-主体生命周期不能为空",false);
      omsEvaCycleConf_2 = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaCycleConf_2== null||  omsEvaCycleConf_2.getFillinTimeRuleCode() ==null,"找不到数据，系统异常",false);


           }
ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto_3 = null;
    if(omsEvaCycleConf_2 !=null){
          ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto_2=new ObtainCycleTimeRuleInfoComReqDto();
  if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      obtainCycleTimeRuleInfoComReqDto_2.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_71355
    }
if(reqDto!=null){
      obtainCycleTimeRuleInfoComReqDto_2.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_71355
obtainCycleTimeRuleInfoComReqDto_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_71355
obtainCycleTimeRuleInfoComReqDto_2.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1784922_1_71355
obtainCycleTimeRuleInfoComReqDto_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_71355
    }
if(omsEvaCycleConf_2!=null){
      obtainCycleTimeRuleInfoComReqDto_2.setTimeRuleCode(omsEvaCycleConf_2.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_71355
    }

    /*D3-2时段规则分析4个时间点(公共)[3519]   */
    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getExecuteCycleStageId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getCycleId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getTimeRuleCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_2.getEvaluationTemplateId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空",false);
      obtainCycleTimeRuleInfoComRespDto_3 = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto_2)/*vcase invoke isSameApp*/;



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
    if(obtainCycleTimeRuleInfoComRespDto_3 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(obtainCycleTimeRuleInfoComRespDto_3!=null){
      receptionServiceReq_3.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto_3.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_71356
receptionServiceReq_3.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto_3.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_71356
receptionServiceReq_3.setComTimeField1(obtainCycleTimeRuleInfoComRespDto_3.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_71356
receptionServiceReq_3.setComTimeField2(obtainCycleTimeRuleInfoComRespDto_3.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_71356
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTimePeriodStartTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空",false);
Assert.isNull(receptionServiceReq_3.getTimePeriodEndTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空",false);
      receptionServiceRes_5 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
           }
      }
else if((queryConfItemMatchAnswerDetailComRespDto_2!= null&& queryConfItemMatchAnswerDetailComRespDto_2.getExtensionField2() == null &&reqDto!= null&&  reqDto.getCycleMode() !=null && reqDto.getCycleMode().equals("FATHER_SON_CYCLE"))&&(reqDto!= null&&  reqDto.getIsFatherCycle() !=null && reqDto.getIsFatherCycle().equals("TRUE")||reqDto!= null&&  reqDto.getIsMetaphase() !=null && reqDto.getIsMetaphase().equals("TRUE"))){
       //elseif((D2-3查周期类型的周期配置标识.扩展字段2（非必填） 值等于空  and D3-获取执行周期时段规则(公共).周期模式 等于 父子周期) and (D3-获取执行周期时段规则(公共).是否父周期 等于 是 or D3-获取执行周期时段规则(公共).是否中期 等于 是))  71357

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1784944_1_71358
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setConfSchemeId(reqDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1784935_1_71358
queryConfItemMatchAnswerDetailComReqDto_2.setConfOptionCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1784938_1_71358
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1784933_1_71358
    }

    /*D2-3查周期类型的周期配置标识[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfSchemeId(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置方案ID 不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfOptionCode(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-选项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(),"D3-获取执行周期时段规则(公共)-D2-3查周期类型的周期配置标识-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_3 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto_3!= null&& queryConfItemMatchAnswerDetailComRespDto_3.getExtensionField2() != null )) {
        //if(D2-3查子周期类型的周期配置标识.扩展字段2（非必填） 值不等于空 )  71361

OmsEvaCycleConf omsEvaCycleConf_3 = null;
    if(queryConfItemMatchAnswerDetailComRespDto_3 !=null){
          QueryCycleConfDetailReq queryCycleConfDetailReq_2=new QueryCycleConfDetailReq();
  queryCycleConfDetailReq_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1785050_1_71365
if(queryConfItemMatchAnswerDetailComRespDto_3!=null){
      queryCycleConfDetailReq_2.setCycleConfCode(queryConfItemMatchAnswerDetailComRespDto_3.getExtensionField2());//SimpleFieldAssign//sourceId:1785048_1_71365
    }
if(reqDto!=null){
      queryCycleConfDetailReq_2.setCycleTypeCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1785076_1_71365
    }

    /*3-2-08查周期配置详情[2360]   */
    Assert.isNull(queryCycleConfDetailReq_2.getCycleConfCode(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期配置标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq_2.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-周期类型标识不能为空",false);
Assert.isNull(queryCycleConfDetailReq_2.getSubjectLifeCycle(),"D3-获取执行周期时段规则(公共)-3-2-08查周期配置详情-主体生命周期不能为空",false);
      omsEvaCycleConf_3 = mOmsEvaCycleConfService.queryCycleConfDetail(queryCycleConfDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaCycleConf_3== null||  omsEvaCycleConf_3.getFillinTimeRuleCode() ==null,"找不到数据，系统异常",false);


           }
ObtainCycleTimeRuleInfoComRespDto obtainCycleTimeRuleInfoComRespDto_4 = null;
    if(omsEvaCycleConf_3 !=null){
          ObtainCycleTimeRuleInfoComReqDto obtainCycleTimeRuleInfoComReqDto_3=new ObtainCycleTimeRuleInfoComReqDto();
  if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      obtainCycleTimeRuleInfoComReqDto_3.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:972791_1_71366
    }
if(reqDto!=null){
      obtainCycleTimeRuleInfoComReqDto_3.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:972792_1_71366
obtainCycleTimeRuleInfoComReqDto_3.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:972790_1_71366
obtainCycleTimeRuleInfoComReqDto_3.setCycleTypeCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1784922_1_71366
obtainCycleTimeRuleInfoComReqDto_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:972793_1_71366
    }
if(omsEvaCycleConf_3!=null){
      obtainCycleTimeRuleInfoComReqDto_3.setTimeRuleCode(omsEvaCycleConf_3.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:1784923_1_71366
    }

    /*D3-2时段规则分析4个时间点(公共)[3519]   */
    Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getExecuteCycleStageId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-执行周期阶段ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getCycleId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期ID不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getTimeRuleCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-时段规则标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getCycleTypeCode(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-周期类型标识不能为空",false);
Assert.isNull(obtainCycleTimeRuleInfoComReqDto_3.getEvaluationTemplateId(),"D3-获取执行周期时段规则(公共)-D3-2时段规则分析4个时间点(公共)-冗余评价模板ID不能为空",false);
      obtainCycleTimeRuleInfoComRespDto_4 = cycleConfService.obtainCycleTimeRuleInfoCom(obtainCycleTimeRuleInfoComReqDto_3)/*vcase invoke isSameApp*/;



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    if(obtainCycleTimeRuleInfoComRespDto_4 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_4=new CalculateAcceptAboveFieldsReqDto();
  if(obtainCycleTimeRuleInfoComRespDto_4!=null){
      receptionServiceReq_4.setTimePeriodStartTime(obtainCycleTimeRuleInfoComRespDto_4.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973015_1_71367
receptionServiceReq_4.setTimePeriodEndTime(obtainCycleTimeRuleInfoComRespDto_4.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973016_1_71367
receptionServiceReq_4.setComTimeField1(obtainCycleTimeRuleInfoComRespDto_4.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973030_1_71367
receptionServiceReq_4.setComTimeField2(obtainCycleTimeRuleInfoComRespDto_4.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973031_1_71367
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getTimePeriodStartTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段开始时间不能为空",false);
Assert.isNull(receptionServiceReq_4.getTimePeriodEndTime(),"D3-获取执行周期时段规则(公共)-约定出参：填报、评价时段-时段结束时间不能为空",false);
      receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
           }
      }
else{
       //else  71363

//异常结束 71364
      throw new BizException("220200406","对不起，周期类型的周期配置未设置~",false);
    }
    }
else{
       //else  71359

//异常结束 71360
      throw new BizException("220200406","对不起，周期类型的周期配置未设置~",false);
           }
    }
ObtainExecuteCycleTimeRuleComRespDto retData = new ObtainExecuteCycleTimeRuleComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTimePeriodStartTime(receptionServiceRes_3.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973077_1
retData.setTimePeriodEndTime(receptionServiceRes_3.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973078_1
retData.setFollowTimePeriodStartTime(receptionServiceRes_3.getComTimeField1());//SimpleFieldAssign//sourceId:973079_1
retData.setFollowTimePeriodEndTime(receptionServiceRes_3.getComTimeField2());//SimpleFieldAssign//sourceId:973080_1
    }




return retData;
  }
/**
   * D3-获取评价模版时段规则(公共)[6904]
   * gen by moon at 5/22/2023, 4:39:10 AM
   */
  @Trace(operationName = "D3-获取评价模版时段规则(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainEvaTemplateTimeRuleComRespDto obtainEvaTemplateTimeRuleCom(ObtainEvaTemplateTimeRuleComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage 3-4-05查时段规则详情  42615
      OmsCycleTimeRule omsCycleTimeRule = null;
    QueryCycleTimeRuleDetailReq queryCycleTimeRuleDetailReq=new QueryCycleTimeRuleDetailReq();
  queryCycleTimeRuleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:973265_1_42615
if(reqDto!=null){
      queryCycleTimeRuleDetailReq.setTimeRuleCode(reqDto.getFillinTimeRuleCode());//SimpleFieldAssign//sourceId:973250_1_42615
    }

    /*3-4-05查时段规则详情[2361]   */
    Assert.isNull(queryCycleTimeRuleDetailReq.getTimeRuleCode(),"D3-获取评价模版时段规则(公共)-3-4-05查时段规则详情-时段规则标识不能为空",false);
Assert.isNull(queryCycleTimeRuleDetailReq.getSubjectLifeCycle(),"D3-获取评价模版时段规则(公共)-3-4-05查时段规则详情-主体生命周期不能为空",false);
      omsCycleTimeRule = mOmsCycleTimeRuleService.queryCycleTimeRuleDetail(queryCycleTimeRuleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage D3-判断执行周期是否完整(公共)  42616
      JudgeExecuteCycleStageIsIntactComRespDto judgeExecuteCycleStageIsIntactComRespDto = null;
    JudgeExecuteCycleStageIsIntactComReqDto judgeExecuteCycleStageIsIntactComReqDto=new JudgeExecuteCycleStageIsIntactComReqDto();
  if(reqDto!=null){
      judgeExecuteCycleStageIsIntactComReqDto.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:973267_1_42616
judgeExecuteCycleStageIsIntactComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:973268_1_42616
judgeExecuteCycleStageIsIntactComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:973269_1_42616
    }

    /*D3-判断执行周期是否完整(公共)[5465]   */
    Assert.isNull(judgeExecuteCycleStageIsIntactComReqDto.getExecuteCycleStageId(),"D3-获取评价模版时段规则(公共)-D3-判断执行周期是否完整(公共)-执行周期阶段ID不能为空",false);
Assert.isNull(judgeExecuteCycleStageIsIntactComReqDto.getCycleId(),"D3-获取评价模版时段规则(公共)-D3-判断执行周期是否完整(公共)-周期ID不能为空",false);
Assert.isNull(judgeExecuteCycleStageIsIntactComReqDto.getEvaluationTemplateId(),"D3-获取评价模版时段规则(公共)-D3-判断执行周期是否完整(公共)-冗余评价模板ID不能为空",false);
      judgeExecuteCycleStageIsIntactComRespDto = targetCycleService.judgeExecuteCycleStageIsIntactCom(judgeExecuteCycleStageIsIntactComReqDto)/*vcase invoke isSameApp*/;



if((omsCycleTimeRule!= null&&  omsCycleTimeRule.getStartStopType() !=null && omsCycleTimeRule.getStartStopType().equals("LAST_DAY_CYCLE")&&judgeExecuteCycleStageIsIntactComRespDto!= null&&  judgeExecuteCycleStageIsIntactComRespDto.getComTxtField() !=null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField().equals("TRUE"))) {
        //if((3-4-05查时段规则详情.参照哪一天 等于 周期最后一天 and D3-判断执行周期是否完整(公共).执行周期是否完整 等于 是))  42618

OmsCycle omsCycle = null;
    QueryCycleDetailReq queryCycleDetailReq=new QueryCycleDetailReq();
  queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:974581_1_42619
if(reqDto!=null){
      queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:974580_1_42619
    }

    /*3-4-04查询周期详情[2004]   */
    Assert.isNull(queryCycleDetailReq.getCycleId(),"D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-周期ID不能为空",false);
Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(),"D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: cycleShift
        ImplementCountTimeRulesTimeRespDto cycleShiftRes = null;
    if(omsCycleTimeRule !=null&&omsCycle !=null){
          ImplementCountTimeRulesTimeReqDto cycleShiftReq=new ImplementCountTimeRulesTimeReqDto();
  if(omsCycleTimeRule!=null){
      cycleShiftReq.setTimeRelativeNumber(omsCycleTimeRule.getTimeRelativeNumber());//SimpleFieldAssign//sourceId:973301_1_42620
cycleShiftReq.setTimeNumber(omsCycleTimeRule.getTimeNumber());//SimpleFieldAssign//sourceId:973309_1_42620
cycleShiftReq.setFollowTimeNumber(omsCycleTimeRule.getFollowTimeNumber());//SimpleFieldAssign//sourceId:973310_1_42620
cycleShiftReq.setStartStopType(omsCycleTimeRule.getStartStopType());//SimpleFieldAssign//sourceId:973304_1_42620
cycleShiftReq.setIsContains(omsCycleTimeRule.getIsContains());//SimpleFieldAssign//sourceId:973305_1_42620
cycleShiftReq.setCalculateType(omsCycleTimeRule.getCalculateType());//SimpleFieldAssign//sourceId:973303_1_42620
cycleShiftReq.setTimeUnit(omsCycleTimeRule.getTimeUnit());//SimpleFieldAssign//sourceId:973302_1_42620
    }
if(omsCycle!=null){
      cycleShiftReq.setReferenceCycleTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:973306_1_42620
    }

    /*M3执行计算时段规则时间（特殊方法）[2365]  入参时间字段，偏移数（正整数），正向偏移或反向偏移 */
    Assert.isNull(cycleShiftReq.getTimeRelativeNumber(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-相对周期提前或延后数量 不能为空",false);
Assert.isNull(cycleShiftReq.getTimeNumber(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时段区间数量不能为空",false);
Assert.isNull(cycleShiftReq.getFollowTimeNumber(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-跟随时段区间数量不能为空",false);
Assert.isNull(cycleShiftReq.getReferenceCycleTime(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照周期时间不能为空",false);
Assert.isNull(cycleShiftReq.getStartStopType(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照哪一天不能为空",false);
Assert.isNull(cycleShiftReq.getIsContains(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-是否包含参照这一天不能为空",false);
Assert.isNull(cycleShiftReq.getCalculateType(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-计算类型不能为空",false);
Assert.isNull(cycleShiftReq.getTimeUnit(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时间单位不能为空",false);
      cycleShiftRes = nbCustomExecutionCycle.implementCountTimeRulesTime(cycleShiftReq);



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(cycleShiftRes!=null){
      receptionServiceReq.setTimePeriodStartTime(cycleShiftRes.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973527_1_42621
receptionServiceReq.setTimePeriodEndTime(cycleShiftRes.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973528_1_42621
receptionServiceReq.setComTimeField1(cycleShiftRes.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973529_1_42621
receptionServiceReq.setComTimeField2(cycleShiftRes.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973530_1_42621
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((omsCycleTimeRule!= null&&  omsCycleTimeRule.getStartStopType() !=null && omsCycleTimeRule.getStartStopType().equals("FIRST_DAT_CYCLE")&&judgeExecuteCycleStageIsIntactComRespDto!= null&&  judgeExecuteCycleStageIsIntactComRespDto.getComTxtField() !=null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField().equals("TRUE"))){
       //elseif((3-4-05查时段规则详情.参照哪一天 等于 周期第一天 and D3-判断执行周期是否完整(公共).执行周期是否完整 等于 是))  42622

//ModelCode: getLastAndNextCycle
        ObtainGetNextCycleRespDto getLastAndNextCycleRes = null;
    ObtainGetNextCycleReqDto getLastAndNextCycleReq=new ObtainGetNextCycleReqDto();
  if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      getLastAndNextCycleReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:973363_1_42623
    }
if(reqDto!=null){
      getLastAndNextCycleReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:973365_1_42623
getLastAndNextCycleReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:973366_1_42623
    }

    /*M3-获取获取当前周期下一个周期（特殊方法）[4754]  入参：当前时间，数据集【周期ID、周期开始时间、周期结束时间】 逻辑：根据当前时间与数据集中数据开始时间、结束时间比较，获取当前周期ID以及下一个周期ID、上一个周期ID 出参：当前周期ID、下一个周期ID、上一个周期ID */
    Assert.isNull(getLastAndNextCycleReq.getCycleId(),"D3-获取评价模版时段规则(公共)-M3-获取获取当前周期下一个周期（特殊方法）-周期ID不能为空",false);
Assert.isNull(getLastAndNextCycleReq.getCycleTypeCode(),"D3-获取评价模版时段规则(公共)-M3-获取获取当前周期下一个周期（特殊方法）-周期类型标识不能为空",false);
      getLastAndNextCycleRes = nbCustomExecutionCycle.obtainGetNextCycle(getLastAndNextCycleReq);



OmsCycle omsCycle_2 = null;
    QueryCycleDetailReq queryCycleDetailReq_1=new QueryCycleDetailReq();
  queryCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:974581_1_42624
if(getLastAndNextCycleRes!=null){
      queryCycleDetailReq_1.setCycleId(getLastAndNextCycleRes.getCycleId());//SimpleFieldAssign//sourceId:974580_1_42624
    }

    /*3-4-04查询周期详情[2004]   */
    Assert.isNull(queryCycleDetailReq_1.getCycleId(),"D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-周期ID不能为空",false);
Assert.isNull(queryCycleDetailReq_1.getSubjectLifeCycle(),"D3-获取评价模版时段规则(公共)-3-4-04查询周期详情-主体生命周期不能为空",false);
      omsCycle_2 = mOmsCycleService.queryCycleDetail(queryCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: cycleShift
        ImplementCountTimeRulesTimeRespDto cycleShiftRes_2 = null;
    if(omsCycleTimeRule !=null&&omsCycle_2 !=null){
          ImplementCountTimeRulesTimeReqDto cycleShiftReq_1=new ImplementCountTimeRulesTimeReqDto();
  if(omsCycleTimeRule!=null){
      cycleShiftReq_1.setTimeRelativeNumber(omsCycleTimeRule.getTimeRelativeNumber());//SimpleFieldAssign//sourceId:973301_1_42625
cycleShiftReq_1.setTimeNumber(omsCycleTimeRule.getTimeNumber());//SimpleFieldAssign//sourceId:973309_1_42625
cycleShiftReq_1.setFollowTimeNumber(omsCycleTimeRule.getFollowTimeNumber());//SimpleFieldAssign//sourceId:973310_1_42625
cycleShiftReq_1.setStartStopType(omsCycleTimeRule.getStartStopType());//SimpleFieldAssign//sourceId:973304_1_42625
cycleShiftReq_1.setIsContains(omsCycleTimeRule.getIsContains());//SimpleFieldAssign//sourceId:973305_1_42625
cycleShiftReq_1.setCalculateType(omsCycleTimeRule.getCalculateType());//SimpleFieldAssign//sourceId:973303_1_42625
cycleShiftReq_1.setTimeUnit(omsCycleTimeRule.getTimeUnit());//SimpleFieldAssign//sourceId:973302_1_42625
    }
if(omsCycle_2!=null){
      cycleShiftReq_1.setReferenceCycleTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:973306_1_42625
    }

    /*M3执行计算时段规则时间（特殊方法）[2365]  入参时间字段，偏移数（正整数），正向偏移或反向偏移 */
    Assert.isNull(cycleShiftReq_1.getTimeRelativeNumber(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-相对周期提前或延后数量 不能为空",false);
Assert.isNull(cycleShiftReq_1.getTimeNumber(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时段区间数量不能为空",false);
Assert.isNull(cycleShiftReq_1.getFollowTimeNumber(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-跟随时段区间数量不能为空",false);
Assert.isNull(cycleShiftReq_1.getReferenceCycleTime(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照周期时间不能为空",false);
Assert.isNull(cycleShiftReq_1.getStartStopType(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-参照哪一天不能为空",false);
Assert.isNull(cycleShiftReq_1.getIsContains(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-是否包含参照这一天不能为空",false);
Assert.isNull(cycleShiftReq_1.getCalculateType(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-计算类型不能为空",false);
Assert.isNull(cycleShiftReq_1.getTimeUnit(),"D3-获取评价模版时段规则(公共)-M3执行计算时段规则时间（特殊方法）-时间单位不能为空",false);
      cycleShiftRes_2 = nbCustomExecutionCycle.implementCountTimeRulesTime(cycleShiftReq_1);



           }
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(cycleShiftRes_2!=null){
      receptionServiceReq_1.setTimePeriodStartTime(cycleShiftRes_2.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:973527_1_42626
receptionServiceReq_1.setTimePeriodEndTime(cycleShiftRes_2.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:973528_1_42626
receptionServiceReq_1.setComTimeField1(cycleShiftRes_2.getFollowTimePeriodStartTime());//SimpleFieldAssign//sourceId:973529_1_42626
receptionServiceReq_1.setComTimeField2(cycleShiftRes_2.getFollowTimePeriodEndTime());//SimpleFieldAssign//sourceId:973530_1_42626
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
    }
else if((judgeExecuteCycleStageIsIntactComRespDto!= null&&  judgeExecuteCycleStageIsIntactComRespDto.getComTxtField() !=null && judgeExecuteCycleStageIsIntactComRespDto.getComTxtField().equals("FALSE"))){
       //elseif(D3-判断执行周期是否完整(公共).执行周期是否完整 等于 否)  42627

OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:974569_1_42628
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:974567_1_42628
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:974568_1_42628
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(),"D3-获取评价模版时段规则(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-获取评价模版时段规则(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-获取评价模版时段规则(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
    if(omsExecuteCycleStage !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(omsExecuteCycleStage!=null){
      receptionServiceReq_2.setTimePeriodStartTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:973527_1_42629
receptionServiceReq_2.setTimePeriodEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:973528_1_42629
receptionServiceReq_2.setComTimeField1(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:973529_1_42629
receptionServiceReq_2.setComTimeField2(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:973530_1_42629
    }

    /*约定出参：填报、评价时段[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
ObtainEvaTemplateTimeRuleComRespDto retData = new ObtainEvaTemplateTimeRuleComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setTimePeriodStartTime(receptionServiceRes_1.getTimePeriodStartTime());//SimpleFieldAssign//sourceId:974593_1
retData.setTimePeriodEndTime(receptionServiceRes_1.getTimePeriodEndTime());//SimpleFieldAssign//sourceId:974594_1
retData.setFollowTimePeriodStartTime(receptionServiceRes_1.getComTimeField1());//SimpleFieldAssign//sourceId:974595_1
retData.setFollowTimePeriodEndTime(receptionServiceRes_1.getComTimeField2());//SimpleFieldAssign//sourceId:974596_1
    }




return retData;
  }
/**
   * D3-查周期类型相关配置(公共)[6948]
   * gen by moon at 5/5/2024, 7:20:48 PM
   */
  @Trace(operationName = "D3-查周期类型相关配置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSpecProcessCycleIsOpenComRespDto implementSpecProcessCycleIsOpenCom(ImplementSpecProcessCycleIsOpenComReqDto reqDto){


      OmsEvaluationTemplate omsEvaluationTemplate_1 =null;
QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_1 =null;
QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_3 =null;
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_7 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_9 =null;
CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 =null;
ImplementFiveReceivingFieldRespDto receptionServiceRes_8 =null;
//virtualUsage 3-2-02查评价模板详情  43097
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:984039_1_43097
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984038_1_43097
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-查周期类型相关配置(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3-查周期类型相关配置(公共)-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationTemplate_1 = omsEvaluationTemplate;
//virtualUsage 3-3-01查目标周期模式  64992
      OmsTarget omsTarget = null;
    if(omsEvaluationTemplate !=null){
          QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  if(omsEvaluationTemplate!=null){
      queryTargetDetailReq.setTargetId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1654680_1_64992
queryTargetDetailReq.setEvaluationTemplateId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1654681_1_64992
    }

    /*3-3-01查目标周期模式[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetId(),"D3-查周期类型相关配置(公共)-3-3-01查目标周期模式-目标ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getEvaluationTemplateId(),"D3-查周期类型相关配置(公共)-3-3-01查目标周期模式-归属评价模板ID不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(D3-特殊过程周期类型启用判断(公共).关联目标内容类型编码 等于 目标)  43086

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:984005_1_43090

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-查周期类型相关配置(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);



QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983670_1_43092
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerListComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:983677_1_43092
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerListComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:983673_1_43092
    }

    /*D2-3查模版启用周期类型列表[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-是否标准答案不能为空",false);
      queryConfItemMatchAnswerListComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerListComRespDto== null||  queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() ==null|| CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())|| queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().size()==0 ,"找不到数据，系统异常",false);

      queryConfItemMatchAnswerListComRespDto_1 = queryConfItemMatchAnswerListComRespDto;
           }
QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_2 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto_1=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto_1.setConfItemCode("PROCESS_STAGE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983661_1_43093
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerListComReqDto_1.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:983668_1_43093
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerListComReqDto_1.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:983664_1_43093
    }

    /*D2-3查模版启用过程周期类型[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto_1.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto_1.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerListComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerListComRespDto_3 = queryConfItemMatchAnswerListComRespDto_2;
           }
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SUBCYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980813_1_43094
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:980824_1_43094
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:980822_1_43094
    }

    /*D2-3查模版子周期类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    if(omsEvaluationTemplate !=null){
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("LAST_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980798_1_43095
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:980828_1_43095
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:980807_1_43095
    }

    /*D2-3查模版末级周期类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
    if(omsEvaluationTemplate !=null){
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("SECOND_LAST_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1654633_1_64986
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:1654644_1_64986
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:1654642_1_64986
    }

    /*D2查第二末级周期类型配置（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2查第二末级周期类型配置（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2查第二末级周期类型配置（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_4 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



      }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_6 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("IS_OPEN_SPEC_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980784_1_43104
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_3.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:980829_1_43104
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:980793_1_43104
    }

    /*D2-3查是否开启过程特殊周期类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_6 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_7 = queryConfItemMatchAnswerDetailComRespDto_6;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_8 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_4=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_4.setConfItemCode("TEMP_SPEC_CYCLE_TYPE_CONF");//CUSTOM_CONVENTION//sourceId:984078_1_43106
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_4.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:984089_1_43106
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_4.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:984087_1_43106
    }

    /*D2-3查模板启用的特殊周期类型答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_8 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_9 = queryConfItemMatchAnswerDetailComRespDto_8;
           }
QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto=new QueryOptionMatchResultExtendDetailComReqDto();
  queryOptionMatchResultExtendDetailComReqDto.setEndValue("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988181_1_43295
queryOptionMatchResultExtendDetailComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:988171_1_43295
if(omsEvaluationTemplate!=null){
      queryOptionMatchResultExtendDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:988185_1_43295
    }
if(receptionServiceRes!=null){
      queryOptionMatchResultExtendDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:988178_1_43295
      }

    /*D2-3查评价模版是否启用双周周期类型[3232]   */
    Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getEndValue(),"D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-答案值不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-配置项标识不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-是否标准答案不能为空",false);
      queryOptionMatchResultExtendDetailComRespDto = fwCompConfSchemeClient.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryOptionMatchResultExtendDetailComRespDto!= null&& queryOptionMatchResultExtendDetailComRespDto.getOptionResultId() != null )) {
        //if(D2-3查评价模版是否启用双周周期类型.答案ID 值不等于空 )  43296

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(queryOptionMatchResultExtendDetailComRespDto !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43298
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43298
    }
if(queryOptionMatchResultExtendDetailComRespDto!=null){
      receptionServiceReq_1.setIsLastCycle(queryOptionMatchResultExtendDetailComRespDto.getExtensionField1());//SimpleFieldAssign//sourceId:988361_1_43298
receptionServiceReq_1.setCustomField(queryOptionMatchResultExtendDetailComRespDto.getExtensionField2());//SimpleFieldAssign//sourceId:988398_1_43298
receptionServiceReq_1.setNextCyclePeriod(queryOptionMatchResultExtendDetailComRespDto.getExtensionField3());//SimpleFieldAssign//sourceId:988362_1_43298
    }

    /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((queryOptionMatchResultExtendDetailComRespDto!= null&& queryOptionMatchResultExtendDetailComRespDto.getOptionResultId() == null )){
       //elseif(D2-3查评价模版是否启用双周周期类型.答案ID 值等于空 )  43297

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_2.setTureOrFalse("FALSE");//sourceId:984003_1_43300

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3-查周期类型相关配置(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_4 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_2);



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_3.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43299
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setTureOrFalse(receptionServiceRes_4.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43299
    }

    /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_6 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_7 = null;
    if(queryConfItemMatchAnswerDetailComRespDto_4 !=null&&omsTarget !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_4=new ImplementFiveReceivingFieldReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto_4!=null){
      receptionServiceReq_4.setSecondLastCycleType(queryConfItemMatchAnswerDetailComRespDto_4.getEndValue());//SimpleFieldAssign//sourceId:1654980_1_64993
    }
if(omsTarget!=null){
      receptionServiceReq_4.setPeriodicModeTypeCode(omsTarget.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1654981_1_64993
    }

    /*M3接收第二末级周期类型及周期模式类型编码[8467]  用于特殊方法接收上游入参。 */

      receptionServiceRes_7 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_4);


      receptionServiceRes_8 = receptionServiceRes_7;
           }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif((D3-特殊过程周期类型启用判断(公共).关联目标内容类型编码 等于 目标分类 or D3-特殊过程周期类型启用判断(公共).关联目标内容类型编码 等于 指标))  43089

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_5.setTureOrFalse("FALSE");//sourceId:984003_1_43098

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getTureOrFalse(),"D3-查周期类型相关配置(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_9 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_5);



QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_4 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto_2=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto_2.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983670_1_43100
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerListComReqDto_2.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983672_1_43100
    }
if(receptionServiceRes_9!=null){
      queryConfItemMatchAnswerListComReqDto_2.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:983673_1_43100
    }

    /*D2-3查模版启用周期类型列表[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto_2.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto_2.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版启用周期类型列表-是否标准答案不能为空",false);
      queryConfItemMatchAnswerListComRespDto_4 = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerListComRespDto_4== null||  queryConfItemMatchAnswerListComRespDto_4.getConfSchemeItemResultList() ==null|| CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto_4.getConfSchemeItemResultList())|| queryConfItemMatchAnswerListComRespDto_4.getConfSchemeItemResultList().size()==0 ,"找不到数据，系统异常",false);

      queryConfItemMatchAnswerListComRespDto_1 = queryConfItemMatchAnswerListComRespDto_4;
           }
QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto_5 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto_3=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto_3.setConfItemCode("PROCESS_STAGE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:983661_1_43101
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerListComReqDto_3.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983663_1_43101
    }
if(receptionServiceRes_9!=null){
      queryConfItemMatchAnswerListComReqDto_3.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:983664_1_43101
    }

    /*D2-3查模版启用过程周期类型[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto_3.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto_3.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版启用过程周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerListComRespDto_5 = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerListComRespDto_3 = queryConfItemMatchAnswerListComRespDto_5;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_10 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_5=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_5.setConfItemCode("SUBCYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980813_1_43102
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983679_1_43102
    }
if(receptionServiceRes_9!=null){
      queryConfItemMatchAnswerDetailComReqDto_5.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:980822_1_43102
    }

    /*D2-3查模版子周期类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版子周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_10 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto_10;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_11 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_6=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_6.setConfItemCode("LAST_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980798_1_43103
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_6.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983680_1_43103
    }
if(receptionServiceRes_9!=null){
      queryConfItemMatchAnswerDetailComReqDto_6.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:980807_1_43103
    }

    /*D2-3查模版末级周期类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模版末级周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_11 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_6).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_11;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_12 = null;
    if(omsEvaluationTemplate !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_7=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_7.setConfItemCode("IS_OPEN_SPEC_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:980784_1_43105
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_7.setResultAspObjId(omsEvaluationTemplate.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:983678_1_43105
    }
if(receptionServiceRes_9!=null){
      queryConfItemMatchAnswerDetailComReqDto_7.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:980793_1_43105
    }

    /*D2-3查是否开启过程特殊周期类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_7.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_7.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查是否开启过程特殊周期类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_12 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_7).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_7 = queryConfItemMatchAnswerDetailComRespDto_12;
           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_13 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_8=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_8.setConfItemCode("TEMP_SPEC_CYCLE_TYPE_CONF");//CUSTOM_CONVENTION//sourceId:984078_1_43107
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_8.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984080_1_43107
    }
if(receptionServiceRes_9!=null){
      queryConfItemMatchAnswerDetailComReqDto_8.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:984087_1_43107
    }

    /*D2-3查模板启用的特殊周期类型答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_8.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_8.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查模板启用的特殊周期类型答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_13 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_8).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_9 = queryConfItemMatchAnswerDetailComRespDto_13;
QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto_2 = null;
    QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto_1=new QueryOptionMatchResultExtendDetailComReqDto();
  queryOptionMatchResultExtendDetailComReqDto_1.setEndValue("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988181_1_43301
queryOptionMatchResultExtendDetailComReqDto_1.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:988171_1_43301
if(reqDto!=null){
      queryOptionMatchResultExtendDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:988173_1_43301
    }
if(receptionServiceRes_9!=null){
      queryOptionMatchResultExtendDetailComReqDto_1.setIsPlatData(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:988178_1_43301
    }

    /*D2-3查评价模版是否启用双周周期类型[3232]   */
    Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getEndValue(),"D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-答案值不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getConfItemCode(),"D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-配置项标识不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getIsPlatData(),"D3-查周期类型相关配置(公共)-D2-3查评价模版是否启用双周周期类型-是否标准答案不能为空",false);
      queryOptionMatchResultExtendDetailComRespDto_2 = fwCompConfSchemeClient.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryOptionMatchResultExtendDetailComRespDto_2!= null&& queryOptionMatchResultExtendDetailComRespDto_2.getOptionResultId() != null )) {
        //if(D2-3查评价模版是否启用双周周期类型.答案ID 值不等于空 )  43302

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_6.setTureOrFalse("TRUE");//sourceId:984005_1_43306

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getTureOrFalse(),"D3-查周期类型相关配置(公共)-约定：是-是否不能为空",false);
      receptionServiceRes_10 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_6);



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_11 = null;
    if(queryOptionMatchResultExtendDetailComRespDto_2 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_7=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_7.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43305
if(receptionServiceRes_10!=null){
      receptionServiceReq_7.setTureOrFalse(receptionServiceRes_10.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43305
    }
if(queryOptionMatchResultExtendDetailComRespDto_2!=null){
      receptionServiceReq_7.setIsLastCycle(queryOptionMatchResultExtendDetailComRespDto_2.getExtensionField1());//SimpleFieldAssign//sourceId:988361_1_43305
receptionServiceReq_7.setCustomField(queryOptionMatchResultExtendDetailComRespDto_2.getExtensionField2());//SimpleFieldAssign//sourceId:988398_1_43305
receptionServiceReq_7.setNextCyclePeriod(queryOptionMatchResultExtendDetailComRespDto_2.getExtensionField3());//SimpleFieldAssign//sourceId:988362_1_43305
    }

    /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_11 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_7);


      receptionServiceRes_3 = receptionServiceRes_11;
           }
      }
else if((queryOptionMatchResultExtendDetailComRespDto_2!= null&& queryOptionMatchResultExtendDetailComRespDto_2.getOptionResultId() == null )){
       //elseif(D2-3查评价模版是否启用双周周期类型.答案ID 值等于空 )  43303

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_12 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_8=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_8.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:988573_1_43304
if(receptionServiceRes_9!=null){
      receptionServiceReq_8.setTureOrFalse(receptionServiceRes_9.getTureOrFalse());//SimpleFieldAssign//sourceId:988358_1_43304
    }

    /*约定出参：双周周期类型配置[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_12 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_8);


      receptionServiceRes_3 = receptionServiceRes_12;
    }
    }
ImplementSpecProcessCycleIsOpenComRespDto retData = new ImplementSpecProcessCycleIsOpenComRespDto();
  if(queryConfItemMatchAnswerListComRespDto_1!=null){
      retData.setTemplateOpenCycleTypeList(//objList-to-objLists
        queryConfItemMatchAnswerListComRespDto_1.getConfSchemeItemResultList().stream().map(item -> {
      TemplateOpenCycleTypeDto elm = new TemplateOpenCycleTypeDto();
      if(item!=null){
      elm.setCycleTypeCode(item.getEndValue());//SimpleFieldAssign//sourceId:209444_2
elm.setIsLastCycleType(item.getExtensionField1());//SimpleFieldAssign//sourceId:209448_2
elm.setCycleTypeConfCode(item.getExtensionField2());//SimpleFieldAssign//sourceId:209449_2
elm.setNextCyclePeriod(item.getExtensionField3());//SimpleFieldAssign//sourceId:209450_2
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:984046_1
    }
if(queryConfItemMatchAnswerListComRespDto_3!= null&&  queryConfItemMatchAnswerListComRespDto_3.getConfSchemeItemResultList() !=null&& !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto_3.getConfSchemeItemResultList())){
      retData.setCourseCycleTypeList(queryConfItemMatchAnswerListComRespDto_3.getConfSchemeItemResultList().stream().map(item->item.getEndValue())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:984047_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_7!=null){
      retData.setIsOpenSpecCycleType(queryConfItemMatchAnswerDetailComRespDto_7.getEndValue());//SimpleFieldAssign//sourceId:980811_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_9!=null){
      retData.setTempOpenSpecialCycleType(queryConfItemMatchAnswerDetailComRespDto_9.getEndValue());//SimpleFieldAssign//sourceId:984091_1
    }
if(receptionServiceRes_8!=null){
      retData.setPeriodicModeTypeCode(receptionServiceRes_8.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1654992_1
retData.setSecondLastCycleType(receptionServiceRes_8.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1654991_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_3!=null){
      retData.setLastCycleType(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:984044_1
    }
  if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setSubcycleType(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:984045_1
    }
if(omsEvaluationTemplate_1!=null){
      retData.setTargetId(omsEvaluationTemplate_1.getTargetId());//SimpleFieldAssign//sourceId:984048_1
retData.setEvaTempCreateTime(omsEvaluationTemplate_1.getCreateTime());//SimpleFieldAssign//sourceId:984049_1
    }
if(receptionServiceRes_3!=null){
      retData.setTureOrFalse(receptionServiceRes_3.getTureOrFalse());//SimpleFieldAssign//sourceId:988380_1
retData.setCycleTypeCode(receptionServiceRes_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:988576_1
retData.setIsLastCycle(receptionServiceRes_3.getIsLastCycle());//SimpleFieldAssign//sourceId:988381_1
retData.setCycleTypeConfCode(receptionServiceRes_3.getCustomField());//SimpleFieldAssign//sourceId:988401_1
retData.setNextCyclePeriod(receptionServiceRes_3.getNextCyclePeriod());//SimpleFieldAssign//sourceId:988383_1
    }




return retData;
  }
/**
   * D3-查询目标内容可循环周期类型(公共)[6954]
   * gen by moon at 11/21/2023, 3:23:33 PM
   */
  @Trace(operationName = "D3-查询目标内容可循环周期类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetContentNextCyclePeriodComRespDto implementTargetContentNextCyclePeriodCom(ImplementTargetContentNextCyclePeriodComReqDto reqDto){


      QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(D3-查询目标内容可循环周期类型(公共).关联目标内容类型编码 等于 目标)  43108

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:984484_1_43113

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-查询目标内容可循环周期类型(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);



OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:984316_1_43112
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984315_1_43112
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-查询目标内容可循环周期类型(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3-查询目标内容可循环周期类型(公共)-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
          QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto=new QueryOptionMatchResultExtendDetailComReqDto();
  queryOptionMatchResultExtendDetailComReqDto.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:984098_1_43111
if(reqDto!=null){
      queryOptionMatchResultExtendDetailComReqDto.setEndValue(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:984108_1_43111
    }
if(omsEvaluationTemplate!=null){
      queryOptionMatchResultExtendDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:984112_1_43111
    }
if(receptionServiceRes!=null){
      queryOptionMatchResultExtendDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:984105_1_43111
    }

    /*D2-3查最近可循环周期类型[3232]   */
    Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getEndValue(),"D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-答案值不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getConfItemCode(),"D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-配置项标识不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto.getIsPlatData(),"D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-是否标准答案不能为空",false);
      queryOptionMatchResultExtendDetailComRespDto = fwCompConfSchemeClient.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryOptionMatchResultExtendDetailComRespDto_1 = queryOptionMatchResultExtendDetailComRespDto;
           }
    }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif((D3-查询目标内容可循环周期类型(公共).关联目标内容类型编码 等于 目标分类 or D3-查询目标内容可循环周期类型(公共).关联目标内容类型编码 等于 指标))  43109

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:984654_1_43114

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-查询目标内容可循环周期类型(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);



QueryOptionMatchResultExtendDetailComRespDto queryOptionMatchResultExtendDetailComRespDto_2 = null;
          QueryOptionMatchResultExtendDetailComReqDto queryOptionMatchResultExtendDetailComReqDto_1=new QueryOptionMatchResultExtendDetailComReqDto();
  queryOptionMatchResultExtendDetailComReqDto_1.setConfItemCode("TEMP_OPEN_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:984098_1_43110
if(reqDto!=null){
      queryOptionMatchResultExtendDetailComReqDto_1.setEndValue(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:984108_1_43110
queryOptionMatchResultExtendDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:984100_1_43110
    }
if(receptionServiceRes_2!=null){
      queryOptionMatchResultExtendDetailComReqDto_1.setIsPlatData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:984105_1_43110
    }

    /*D2-3查最近可循环周期类型[3232]   */
    Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getEndValue(),"D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-答案值不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getConfItemCode(),"D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-配置项标识不能为空",false);
Assert.isNull(queryOptionMatchResultExtendDetailComReqDto_1.getIsPlatData(),"D3-查询目标内容可循环周期类型(公共)-D2-3查最近可循环周期类型-是否标准答案不能为空",false);
      queryOptionMatchResultExtendDetailComRespDto_2 = fwCompConfSchemeClient.queryOptionMatchResultExtendDetailCom(queryOptionMatchResultExtendDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryOptionMatchResultExtendDetailComRespDto_1 = queryOptionMatchResultExtendDetailComRespDto_2;
    }
ImplementTargetContentNextCyclePeriodComRespDto retData = new ImplementTargetContentNextCyclePeriodComRespDto();
  if(queryOptionMatchResultExtendDetailComRespDto_1!=null){
      retData.setOptionResultId(queryOptionMatchResultExtendDetailComRespDto_1.getOptionResultId());//SimpleFieldAssign//sourceId:1341862_1
      retData.setNextCyclePeriod(queryOptionMatchResultExtendDetailComRespDto_1.getExtensionField3());//SimpleFieldAssign//sourceId:984658_1
    }




return retData;
  }
/**
   * D3-执行时段规则配置判断(公共)[6956]
   * gen by moon at 7/6/2024, 11:54:42 PM
   */
  @Trace(operationName = "D3-执行时段规则配置判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTimeRuleConfComRespDto implementTimeRuleConfCom(ImplementTimeRuleConfComReqDto reqDto){


      OmsEvaluationTemplate omsEvaluationTemplate_1 =null;
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 =null;
//virtualUsage 3-2-02查评价模板配置方案ID  71065
      OmsEvaluationTemplate omsEvaluationTemplate = null;
      QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:985619_1_71065
      if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:985588_1_71065
      }

      /*3-2-02查评价模板配置方案ID[2316]   */
      Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-执行时段规则配置判断(公共)-3-2-02查评价模板配置方案ID-评价模板ID不能为空",false);
      Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3-执行时段规则配置判断(公共)-3-2-02查评价模板配置方案ID-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationTemplate_1 = omsEvaluationTemplate;

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(D3-执行时段规则配置判断(公共).关联目标内容类型编码 等于 目标)  43131

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:985545_1_43133

    /*M3约定：是[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-执行时段规则配置判断(公共)-M3约定：是-是否不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementAcceptField(receptionServiceReq);




QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TIME_RULES_SET_LEVEL");//CUSTOM_CONVENTION//sourceId:985004_1_43134
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:985015_1_43134
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:985013_1_43134
    }

    /*D2-3查时段规则设置级别配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("EVA_TEMP_LEVEL"))) {
        //if(D2-3查时段规则设置级别配置答案.答案值 等于 评价模板级)  43137

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("FILL_TIME_RULES_CODE");//CUSTOM_CONVENTION//sourceId:985549_1_43138
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setConfSchemeId(omsEvaluationTemplate.getConfSchemeId());//SimpleFieldAssign//sourceId:985562_1_43138
    }
if(receptionServiceRes!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:985558_1_43138
    }

    /*D2-3查评价模板填报时段规则标识答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
           }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY")||reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif((D3-执行时段规则配置判断(公共).关联目标内容类型编码 等于 目标分类 or D3-执行时段规则配置判断(公共).关联目标内容类型编码 等于 指标))  43132

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:985547_1_43140

    /*M3约定：否[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-执行时段规则配置判断(公共)-M3约定：否-是否不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.implementAcceptField(receptionServiceReq_1);



QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("TIME_RULES_SET_LEVEL");//CUSTOM_CONVENTION//sourceId:985004_1_43139
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:985006_1_43139
    }
if(receptionServiceRes_2!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:985013_1_43139
    }

    /*D2-3查时段规则设置级别配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(),"D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(),"D3-执行时段规则配置判断(公共)-D2-3查时段规则设置级别配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_4 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto_4;
if((queryConfItemMatchAnswerDetailComRespDto_4!= null&&  queryConfItemMatchAnswerDetailComRespDto_4.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_4.getEndValue().equals("EVA_TEMP_LEVEL"))) {
        //if(D2-3查时段规则设置级别配置答案.答案值 等于 评价模板级)  43141

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_5 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("FILL_TIME_RULES_CODE");//CUSTOM_CONVENTION//sourceId:985549_1_43142
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:985551_1_43142
    }
if(receptionServiceRes_2!=null){
      queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:985558_1_43142
    }

    /*D2-3查评价模板填报时段规则标识答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(),"D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(),"D3-执行时段规则配置判断(公共)-D2-3查评价模板填报时段规则标识答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_5 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_5;
      }
    }
ImplementTimeRuleConfComRespDto retData = new ImplementTimeRuleConfComRespDto();
  if(omsEvaluationTemplate_1!=null){
      retData.setConfSchemeId(omsEvaluationTemplate_1.getConfSchemeId());//SimpleFieldAssign//sourceId:1785032_1
    }
  if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setTimeRulesSetLevel(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:985621_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_3!=null){
      retData.setTimeRuleTypeCode(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:985622_1
    }

Assert.isTrue(retData== null||  retData.getConfSchemeId() ==null,"找不到数据，系统异常",false);



return retData;
  }
/**
   * D3-执行两个月内工作日范围(公共)[6972]
   * gen by moon at 5/27/2023, 5:14:24 PM
   */
  @Trace(operationName = "D3-执行两个月内工作日范围(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementWorkDaysTwoMonthsComRespDto implementWorkDaysTwoMonthsCom(ImplementWorkDaysTwoMonthsComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
QueryWorkDaysTwoMonthsListComRespDto queryWorkDaysTwoMonthsListComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getCycleTypeCode() !=null && reqDto.getCycleTypeCode().equals("WEEK")||reqDto!= null&&  reqDto.getCycleTypeCode() !=null && reqDto.getCycleTypeCode().equals("DOUBLE_WEEKS"))) {
        //if((D3-执行两个月内工作日范围(公共).周期类型标识 等于 周 or D3-执行两个月内工作日范围(公共).周期类型标识 等于 双周))  43226

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq.setComTimeField1(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:986954_1_43231
    }

    /*约定出参：参照时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComTimeField1(),"D3-执行两个月内工作日范围(公共)-约定出参：参照时间-通用时间字段1不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
QueryWorkDaysTwoMonthsListComRespDto queryWorkDaysTwoMonthsListComRespDto = null;
    QueryWorkDaysTwoMonthsListComReqDto queryWorkDaysTwoMonthsListComReqDto=new QueryWorkDaysTwoMonthsListComReqDto();
  if(reqDto!=null){
      queryWorkDaysTwoMonthsListComReqDto.setComTimeField(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:986780_1_43227
    }

    /*D3查询两月内工作日列表(公共)[5348]   */
    Assert.isNull(queryWorkDaysTwoMonthsListComReqDto.getComTimeField(),"D3-执行两个月内工作日范围(公共)-D3查询两月内工作日列表(公共)-通用时间字段不能为空",false);
      queryWorkDaysTwoMonthsListComRespDto = targetCycleService.queryWorkDaysTwoMonthsListCom(queryWorkDaysTwoMonthsListComReqDto)/*vcase invoke isSameApp*/;


      queryWorkDaysTwoMonthsListComRespDto_1 = queryWorkDaysTwoMonthsListComRespDto;
      }
else{
       //else  43228

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq_1.setComTimeField1(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:986954_1_43232
    }

    /*约定出参：参照时间[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getComTimeField1(),"D3-执行两个月内工作日范围(公共)-约定出参：参照时间-通用时间字段1不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
QueryWorkDaysTwoMonthsListComRespDto queryWorkDaysTwoMonthsListComRespDto_2 = null;
    QueryWorkDaysTwoMonthsListComReqDto queryWorkDaysTwoMonthsListComReqDto_1=new QueryWorkDaysTwoMonthsListComReqDto();
  if(reqDto!=null){
      queryWorkDaysTwoMonthsListComReqDto_1.setComTimeField(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:986780_1_43229
    }

    /*D3查询两月内工作日列表(公共)[5348]   */
    Assert.isNull(queryWorkDaysTwoMonthsListComReqDto_1.getComTimeField(),"D3-执行两个月内工作日范围(公共)-D3查询两月内工作日列表(公共)-通用时间字段不能为空",false);
      queryWorkDaysTwoMonthsListComRespDto_2 = targetCycleService.queryWorkDaysTwoMonthsListCom(queryWorkDaysTwoMonthsListComReqDto_1)/*vcase invoke isSameApp*/;


      queryWorkDaysTwoMonthsListComRespDto_1 = queryWorkDaysTwoMonthsListComRespDto_2;
    }
ImplementWorkDaysTwoMonthsComRespDto retData = new ImplementWorkDaysTwoMonthsComRespDto();
  if(queryWorkDaysTwoMonthsListComRespDto_1!=null){
      retData.setWorkDaysTwoMonthsList(queryWorkDaysTwoMonthsListComRespDto_1.getWorkDaysTwoMonthsList().stream().map(item -> BeanUtil.toBean(item, WorkDaysTwoMonthsDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:986782_1
    }
if(receptionServiceRes_1!=null){
      retData.setComTimeField1(receptionServiceRes_1.getComTimeField1());//SimpleFieldAssign//sourceId:986956_1
    }




return retData;
  }
/**
   * D3-执行双周执行周期处理(公共)[6985]
   * gen by moon at 6/9/2024, 10:01:32 PM
   */
  @Trace(operationName = "D3-执行双周执行周期处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementDoubleWeekExecuteCycleComRespDto implementDoubleWeekExecuteCycleCom(ImplementDoubleWeekExecuteCycleComReqDto reqDto){


      //virtualUsage D2生成数据对象批次标识(公共)  69852
      GenerateDataObjectBatchCodeComRespDto generateDataObjectBatchCodeComRespDto = null;
    GenerateDataObjectBatchCodeComReqDto generateDataObjectBatchCodeComReqDto=new GenerateDataObjectBatchCodeComReqDto();


    /*D2生成数据对象批次标识(公共)[9404]   */

      generateDataObjectBatchCodeComRespDto = fwCompInterfaceModeClient.generateDataObjectBatchCodeCom(generateDataObjectBatchCodeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      //virtualUsage D3-新增双周周期(公共)  46150
      AddCreateDoubleWeekCycleComRespDto addCreateDoubleWeekCycleComRespDto = null;
    AddCreateDoubleWeekCycleComReqDto addCreateDoubleWeekCycleComReqDto=new AddCreateDoubleWeekCycleComReqDto();
  if(reqDto!=null){
      addCreateDoubleWeekCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1059096_1_46150
addCreateDoubleWeekCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1059095_1_46150
addCreateDoubleWeekCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1059097_1_46150
    }

    /*D3-新增双周周期(公共)[7242]   */
    Assert.isNull(addCreateDoubleWeekCycleComReqDto.getTargetCycleContentId(),"D3-执行双周执行周期处理(公共)-D3-新增双周周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addCreateDoubleWeekCycleComReqDto.getTargetCycleContentTypeCode(),"D3-执行双周执行周期处理(公共)-D3-新增双周周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addCreateDoubleWeekCycleComReqDto.getEvaluationTemplateId(),"D3-执行双周执行周期处理(公共)-D3-新增双周周期(公共)-冗余评价模板ID不能为空",false);
      addCreateDoubleWeekCycleComRespDto = addCreateDoubleWeekCycleCom(addCreateDoubleWeekCycleComReqDto)/*vcase invoke 同服务,同domain*/;



      //virtualUsage D3-3查询被评对象目标周期列表(公共)  43308
      QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
    QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto=new QueryEvaObjTargetCycleListComReqDto();
  queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:988880_1_43308
queryEvaObjTargetCycleListComReqDto.setEvaObjTableTypeCode("OMS_FRAMEWORK_SPACE");//sourceId:988881_1_43308
queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:988882_1_43308
queryEvaObjTargetCycleListComReqDto.setTreeTypeCode("PLAN_TREE");//sourceId:988883_1_43308
queryEvaObjTargetCycleListComReqDto.setIsSubCycle("TRUE");//sourceId:988886_1_43308
queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:988888_1_43308
if(reqDto!=null){
      queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:988885_1_43308
queryEvaObjTargetCycleListComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:988884_1_43308
queryEvaObjTargetCycleListComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:988887_1_43308
    }

    /*D3-3查询被评对象目标周期列表(公共)[3451]   */
    Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentTypeCode(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsSubCycle(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetId(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-冗余目标ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(),"D3-执行双周执行周期处理(公共)-D3-3查询被评对象目标周期列表(公共)-是否存档不能为空",false);
      queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage M3子周期发牌【循环开始】  43309
      //ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()){

//virtualUsage D3分析子周期双周周期开始时间(公共)  69850
      AnalysisSubCycleBiweeklyStartTimeComRespDto analysisSubCycleBiweeklyStartTimeComRespDto = null;
    if(generateDataObjectBatchCodeComRespDto !=null&&addCreateDoubleWeekCycleComRespDto !=null){
          AnalysisSubCycleBiweeklyStartTimeComReqDto analysisSubCycleBiweeklyStartTimeComReqDto=new AnalysisSubCycleBiweeklyStartTimeComReqDto();
  analysisSubCycleBiweeklyStartTimeComReqDto.setBusinessDataObject("SUB_CYCLE_MAXIMUM_WEEK_INFO");//sourceId:1860689_1_69850
if(generateDataObjectBatchCodeComRespDto!=null){
      analysisSubCycleBiweeklyStartTimeComReqDto.setDataObjectBatchCode(generateDataObjectBatchCodeComRespDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1860688_1_69850
    }
if(addCreateDoubleWeekCycleComRespDto!=null){
      analysisSubCycleBiweeklyStartTimeComReqDto.setTargetActualStartTime(addCreateDoubleWeekCycleComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1860690_1_69850
    }
if(circulationCollectionsRes!=null){
      analysisSubCycleBiweeklyStartTimeComReqDto.setSubCycleTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1860691_1_69850
    }

    /*D3分析子周期双周周期开始时间(公共)[9772]   */
    Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getBusinessDataObject(),"D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-业务数据对象不能为空",false);
Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getDataObjectBatchCode(),"D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-数据对象批次标识不能为空",false);
Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getTargetActualStartTime(),"D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-父周期成果汇报时间不能为空",false);
Assert.isNull(analysisSubCycleBiweeklyStartTimeComReqDto.getSubCycleTargetActualStartTime(),"D3-执行双周执行周期处理(公共)-D3分析子周期双周周期开始时间(公共)-子周期成果汇报开始时间不能为空",false);
      analysisSubCycleBiweeklyStartTimeComRespDto = analysisSubCycleBiweeklyStartTimeCom(analysisSubCycleBiweeklyStartTimeComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D2-根据开始时间结束时间计算双周(公共)  43312
      ImplementCalcDoubleWeekByTimeRangeComRespDto implementCalcDoubleWeekByTimeRangeComRespDto = null;
    if(analysisSubCycleBiweeklyStartTimeComRespDto !=null){
          ImplementCalcDoubleWeekByTimeRangeComReqDto implementCalcDoubleWeekByTimeRangeComReqDto=new ImplementCalcDoubleWeekByTimeRangeComReqDto();
  implementCalcDoubleWeekByTimeRangeComReqDto.setCycleIsCutHeadAndTail("FALSE");//sourceId:1059099_1_43312
if(analysisSubCycleBiweeklyStartTimeComRespDto!=null){
      implementCalcDoubleWeekByTimeRangeComReqDto.setComTimeField(analysisSubCycleBiweeklyStartTimeComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:988801_1_43312
    }
if(circulationCollectionsRes!=null){
      implementCalcDoubleWeekByTimeRangeComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:988802_1_43312
implementCalcDoubleWeekByTimeRangeComReqDto.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:988803_1_43312
    }

    /*D2-根据开始时间结束时间计算双周(公共)[6978]   */
    Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getComTimeField(),"D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-双周起始第一天不能为空",false);
Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleIsCutHeadAndTail(),"D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-周期是否裁剪头尾不能为空",false);
Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleStartTime(),"D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-周期开始时间不能为空",false);
Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleEndTime(),"D3-执行双周执行周期处理(公共)-D2-根据开始时间结束时间计算双周(公共)-周期结束时间不能为空",false);
      implementCalcDoubleWeekByTimeRangeComRespDto = fwCompInterfaceModeClient.implementCalcDoubleWeekByTimeRangeCom(implementCalcDoubleWeekByTimeRangeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D3执行子周期最大双周推内存(公共)  69844
      ImplementSubCycleBigDubbleWeeksMemoryComRespDto implementSubCycleBigDubbleWeeksMemoryComRespDto = null;
    if(generateDataObjectBatchCodeComRespDto !=null&&implementCalcDoubleWeekByTimeRangeComRespDto !=null){
          ImplementSubCycleBigDubbleWeeksMemoryComReqDto implementSubCycleBigDubbleWeeksMemoryComReqDto=new ImplementSubCycleBigDubbleWeeksMemoryComReqDto();
  implementSubCycleBigDubbleWeeksMemoryComReqDto.setBusinessDataObject("SUB_CYCLE_MAXIMUM_WEEK_INFO");//sourceId:1860680_1_69844
if(generateDataObjectBatchCodeComRespDto!=null){
      implementSubCycleBigDubbleWeeksMemoryComReqDto.setDataObjectBatchCode(generateDataObjectBatchCodeComRespDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1860678_1_69844
    }
if(circulationCollectionsRes!=null){
      implementSubCycleBigDubbleWeeksMemoryComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1860679_1_69844
    }
if(implementCalcDoubleWeekByTimeRangeComRespDto!= null&&  implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList() !=null&& !CollectionUtil.isEmpty(implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList())){
    QueryEvaObjTargetCycleListComRespDto finalQueryEvaObjTargetCycleListComRespDto = queryEvaObjTargetCycleListComRespDto;
    implementSubCycleBigDubbleWeeksMemoryComReqDto.setCycleList(//objList-to-objLists
        implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList().stream().map(item -> {
      CycleDto elm = new CycleDto();
      if(item!=null){
      elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:372707_2_69844
          elm.setCycleStartTime(item.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:372705_2_69844
          elm.setCycleEndTime(item.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:372706_2_69844
    }

        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1860677_1_69844
    }

    /*D3执行子周期最大双周推内存(公共)[9771]   */
    Assert.isNull(implementSubCycleBigDubbleWeeksMemoryComReqDto.getBusinessDataObject(),"D3-执行双周执行周期处理(公共)-D3执行子周期最大双周推内存(公共)-业务数据对象不能为空",false);
Assert.isNull(implementSubCycleBigDubbleWeeksMemoryComReqDto.getDataObjectBatchCode(),"D3-执行双周执行周期处理(公共)-D3执行子周期最大双周推内存(公共)-数据对象批次标识不能为空",false);
Assert.isNull(implementSubCycleBigDubbleWeeksMemoryComReqDto.getEvaObjTargetCycleId(),"D3-执行双周执行周期处理(公共)-D3执行子周期最大双周推内存(公共)-被评对象目标周期ID不能为空",false);
      implementSubCycleBigDubbleWeeksMemoryComRespDto = implementSubCycleBigDubbleWeeksMemoryCom(implementSubCycleBigDubbleWeeksMemoryComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((implementCalcDoubleWeekByTimeRangeComRespDto!= null&&  implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList() !=null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList().size()>0)) {
        //if(D2-根据开始时间结束时间计算双周周期名称.双周周期列表数据集条数 大于 0)  43313

//ModelCode: circulationCollections
        for (DoubleWeekDto circulationCollectionsRes_2: implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList()){

OmsCycle omsCycle = null;
    QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq=new QueryTimeRangeFindCycleDetailReq();
  queryTimeRangeFindCycleDetailReq.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:1059107_1_46154
queryTimeRangeFindCycleDetailReq.setPlatformData("TRUE");//sourceId:1059108_1_46154
queryTimeRangeFindCycleDetailReq.setIsArchive("FALSE");//sourceId:1059110_1_46154
if(circulationCollectionsRes_2!=null){
      queryTimeRangeFindCycleDetailReq.setCycleStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1059105_1_46154
queryTimeRangeFindCycleDetailReq.setCycleEndTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1059106_1_46154
    }

    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(),"D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(),"D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(),"D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(),"D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getIsArchive(),"D3-执行双周执行周期处理(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否存档不能为空",false);
      omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsCycle== null||  omsCycle.getCycleId() ==null,"找不到数据，系统异常",false);


OmsExecuteCycleStage omsExecuteCycleStage = null;
    if(omsCycle !=null){
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:989094_1_43337
if(omsCycle!=null){
      queryExecuteCycleStageDetailReq.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1059119_1_43337
    }
if(circulationCollectionsRes!=null){
      queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1816439_1_43337
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:989093_1_43337
queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:989096_1_43337
queryExecuteCycleStageDetailReq.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:989095_1_43337
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:989097_1_43337
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleTypeCode(),"D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(),"D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentTypeCode(),"D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-执行双周执行周期处理(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



    }
if((omsExecuteCycleStage == null )) {
        //if(3-3-07查双周执行周期阶段ID是否存在.出参 值等于空 )  43318

String string = null;
    if(omsCycle !=null){
    OmsExecuteCycleStage omsExecuteCycleStage_2=new OmsExecuteCycleStage();
  omsExecuteCycleStage_2.setIsFatherCycle("FALSE");//sourceId:988844_1_43357
omsExecuteCycleStage_2.setIsMetaphase("FALSE");//sourceId:988846_1_43357
omsExecuteCycleStage_2.setIsSubCycle("FALSE");//sourceId:988845_1_43357
omsExecuteCycleStage_2.setIsProcessCycleStage("TRUE");//sourceId:988847_1_43357
omsExecuteCycleStage_2.setIsStartCycle("FALSE");//sourceId:988852_1_43357
omsExecuteCycleStage_2.setIsEndCycle("FALSE");//sourceId:988853_1_43357
omsExecuteCycleStage_2.setIsCurrentCycle("FALSE");//sourceId:988867_1_43357
omsExecuteCycleStage_2.setIsNextCycle("FALSE");//sourceId:988868_1_43357
if(circulationCollectionsRes!=null){
      omsExecuteCycleStage_2.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:988869_1_43357
    }
if(omsCycle!=null){
      omsExecuteCycleStage_2.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:988841_1_43357
omsExecuteCycleStage_2.setCycleTypeInstanceCode(omsCycle.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1603018_1_43357
    }
if(circulationCollectionsRes_2!=null){
      omsExecuteCycleStage_2.setCycleStandardName(circulationCollectionsRes_2.getCycleStandardName());//SimpleFieldAssign//sourceId:988862_1_43357
omsExecuteCycleStage_2.setCycleStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:988863_1_43357
omsExecuteCycleStage_2.setCycleEndTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:988864_1_43357
omsExecuteCycleStage_2.setFillStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:988857_1_43357
omsExecuteCycleStage_2.setFillEndtTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:988858_1_43357
omsExecuteCycleStage_2.setEvaluateStartTime(circulationCollectionsRes_2.getCycleStartTime());//SimpleFieldAssign//sourceId:991119_1_43357
omsExecuteCycleStage_2.setEvaluateEndtTime(circulationCollectionsRes_2.getCycleEndTime());//SimpleFieldAssign//sourceId:991120_1_43357
omsExecuteCycleStage_2.setCycleTypeCode(circulationCollectionsRes_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:988865_1_43357
omsExecuteCycleStage_2.setOrderNumber(circulationCollectionsRes_2.getOrderNumber());//SimpleFieldAssign//sourceId:988843_1_43357
    }
if(reqDto!=null){
      omsExecuteCycleStage_2.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:988854_1_43357
omsExecuteCycleStage_2.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:988870_1_43357
omsExecuteCycleStage_2.setEvaTempCreateTime(reqDto.getSortCreateTime());//SimpleFieldAssign//sourceId:988842_1_43357
omsExecuteCycleStage_2.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:988848_1_43357
omsExecuteCycleStage_2.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:988850_1_43357
omsExecuteCycleStage_2.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:988849_1_43357
omsExecuteCycleStage_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:988856_1_43357
omsExecuteCycleStage_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:988851_1_43357
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage_2.getEvaObjTargetCycleId(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleId(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleStandardName(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleStartTime(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleEndTime(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getFillStartTime(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getFillEndtTime(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleTypeCode(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsLastCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaTempCreateTime(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getOrderNumber(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-周期排序不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsFatherCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsMetaphase(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsSubCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsProcessCycleStage(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsDefinedExecuteCycleStage(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getRelateContentId(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getRelateContentTypeCode(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getTargetId(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaluationTemplateId(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsStartCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsEndCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsCurrentCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否末级/子周期当前不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsNextCycle(),"D3-执行双周执行周期处理(公共)-3-3-07新增执行周期阶段-是否末级/子周期下一个不能为空",false);
      string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
//ModelCode: circulationEnd
        }

      }
//virtualUsage M3-执行【循环结束】  43310
      //ModelCode: circulationEnd
        }

ImplementDoubleWeekExecuteCycleComRespDto retData = new ImplementDoubleWeekExecuteCycleComRespDto();





return retData;
  }
/**
   * D3撤销修订自定义执行周期处理(公共)[7059]
   * gen by moon at 5/31/2023, 8:19:24 PM
   */
  @Trace(operationName = "D3撤销修订自定义执行周期处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public UndoReviseCustomExecuteCycleDisposeComRespDto undoReviseCustomExecuteCycleDisposeCom(UndoReviseCustomExecuteCycleDisposeComReqDto reqDto){


      //步骤0: 3-3-07-批量查询执行周期阶段列表By目标周期ID - batchQueryExecuteCycleStageListByTargetCycleIds
     List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    BatchQueryExecuteCycleStageListByTargetCycleIdsReq batchQueryExecuteCycleStageListByTargetCycleIdsReq=new BatchQueryExecuteCycleStageListByTargetCycleIdsReq();
  batchQueryExecuteCycleStageListByTargetCycleIdsReq.setIsDefinedExecuteCycleStage("TRUE");//sourceId:998876_1
if(reqDto!=null){
      batchQueryExecuteCycleStageListByTargetCycleIdsReq.setEvaObjTargetCycleList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:998875_1
batchQueryExecuteCycleStageListByTargetCycleIdsReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:998877_1
    }

    /*3-3-07-批量查询执行周期阶段列表By目标周期ID[6508]   */
    Assert.isNull(batchQueryExecuteCycleStageListByTargetCycleIdsReq.getIsDefinedExecuteCycleStage(),"D3撤销修订自定义执行周期处理(公共)-3-3-07-批量查询执行周期阶段列表By目标周期ID-是否自定义执行周期阶段不能为空",false);
Assert.isNull(batchQueryExecuteCycleStageListByTargetCycleIdsReq.getEvaluationTemplateId(),"D3撤销修订自定义执行周期处理(公共)-3-3-07-批量查询执行周期阶段列表By目标周期ID-评价模板ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleStageListByTargetCycleIds(batchQueryExecuteCycleStageListByTargetCycleIdsReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤1: 3-3-07批量删执行周期阶段 - batchDeleteExecuteCycleStage
     boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listString = listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:998861_1
    }

    /*3-3-07批量删执行周期阶段[2743]   */

      bOOLEAN = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;



           }

UndoReviseCustomExecuteCycleDisposeComRespDto retData = new UndoReviseCustomExecuteCycleDisposeComRespDto();





return retData;
  }
/**
   * D3-新增双周周期(公共)[7242]
   * gen by moon at 6/9/2024, 4:34:12 PM
   */
  @Trace(operationName = "D3-新增双周周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddCreateDoubleWeekCycleComRespDto addCreateDoubleWeekCycleCom(AddCreateDoubleWeekCycleComReqDto reqDto){


      QueryEvaObjTargetCycleDetailComRespDto queryEvaObjTargetCycleDetailComRespDto_1 =null;
      //virtualUsage D3-3查询被评对象目标周期详情(公共)  46128
      QueryEvaObjTargetCycleDetailComRespDto queryEvaObjTargetCycleDetailComRespDto = null;
    QueryEvaObjTargetCycleDetailComReqDto queryEvaObjTargetCycleDetailComReqDto=new QueryEvaObjTargetCycleDetailComReqDto();
  queryEvaObjTargetCycleDetailComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1058850_1_46128
queryEvaObjTargetCycleDetailComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1058852_1_46128
queryEvaObjTargetCycleDetailComReqDto.setIsParentCycle("TRUE");//sourceId:1058856_1_46128
queryEvaObjTargetCycleDetailComReqDto.setIsArchive("FALSE");//sourceId:1059072_1_46128
if(reqDto!=null){
      queryEvaObjTargetCycleDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1058855_1_46128
queryEvaObjTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1058857_1_46128
    }

    /*D3-3查询被评对象目标周期详情(公共)[3489]   */
    Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaObjEntityId(),"D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaObjTypeCode(),"D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getTargetCycleContentId(),"D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getIsParentCycle(),"D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getIsArchive(),"D3-新增双周周期(公共)-D3-3查询被评对象目标周期详情(公共)-是否存档不能为空",false);
      queryEvaObjTargetCycleDetailComRespDto = targetCycleService.queryEvaObjTargetCycleDetailCom(queryEvaObjTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


      queryEvaObjTargetCycleDetailComRespDto_1 = queryEvaObjTargetCycleDetailComRespDto;
//virtualUsage 3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）  46129
      OmsCycle omsCycle = null;
    if(queryEvaObjTargetCycleDetailComRespDto !=null){
          QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq=new QueryTimeRangeFindCycleDetailReq();
  queryTimeRangeFindCycleDetailReq.setCycleTypeCode("WEEK");//CUSTOM_CONVENTION//sourceId:1058828_1_46129
queryTimeRangeFindCycleDetailReq.setPlatformData("TRUE");//sourceId:1058829_1_46129
queryTimeRangeFindCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1058830_1_46129
if(queryEvaObjTargetCycleDetailComRespDto!=null){
      queryTimeRangeFindCycleDetailReq.setCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1058826_1_46129
queryTimeRangeFindCycleDetailReq.setCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1058827_1_46129
    }

    /*3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(),"D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(),"D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(),"D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(),"D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-是否是平台不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getSubjectLifeCycle(),"D3-新增双周周期(公共)-3-4-04根据时间范围查询周期详情（开始小于等于结束大于等于）-主体生命周期不能为空",false);
      omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage D2-根据开始时间结束时间计算双周(公共)  46130
      ImplementCalcDoubleWeekByTimeRangeComRespDto implementCalcDoubleWeekByTimeRangeComRespDto = null;
    if(omsCycle !=null&&queryEvaObjTargetCycleDetailComRespDto !=null){
          ImplementCalcDoubleWeekByTimeRangeComReqDto implementCalcDoubleWeekByTimeRangeComReqDto=new ImplementCalcDoubleWeekByTimeRangeComReqDto();
  implementCalcDoubleWeekByTimeRangeComReqDto.setCycleIsCutHeadAndTail("FALSE");//sourceId:1058841_1_46130
if(omsCycle!=null){
      implementCalcDoubleWeekByTimeRangeComReqDto.setComTimeField(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1058837_1_46130
    }
if(queryEvaObjTargetCycleDetailComRespDto!=null){
      implementCalcDoubleWeekByTimeRangeComReqDto.setCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1058838_1_46130
implementCalcDoubleWeekByTimeRangeComReqDto.setCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1058839_1_46130
    }

    /*D2-根据开始时间结束时间计算双周(公共)[6978]   */
    Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getComTimeField(),"D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-双周起始第一天不能为空",false);
Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleIsCutHeadAndTail(),"D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-周期是否裁剪头尾不能为空",false);
Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleStartTime(),"D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-周期开始时间不能为空",false);
Assert.isNull(implementCalcDoubleWeekByTimeRangeComReqDto.getCycleEndTime(),"D3-新增双周周期(公共)-D2-根据开始时间结束时间计算双周(公共)-周期结束时间不能为空",false);
      implementCalcDoubleWeekByTimeRangeComRespDto = fwCompInterfaceModeClient.implementCalcDoubleWeekByTimeRangeCom(implementCalcDoubleWeekByTimeRangeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementCalcDoubleWeekByTimeRangeComRespDto!= null&&  implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList() !=null && implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList().size()>0)) {
        //if(D2-根据开始时间结束时间计算双周(公共).双周周期列表数据集条数 大于 0)  46131

//ModelCode: circulationCollections
        for (DoubleWeekDto circulationCollectionsRes: implementCalcDoubleWeekByTimeRangeComRespDto.getDoubleWeekList()){

OmsCycle omsCycle_2 = null;
    QueryTimeEqualQueryCycleDetailsDetailReq queryTimeEqualQueryCycleDetailsDetailReq=new QueryTimeEqualQueryCycleDetailsDetailReq();
  queryTimeEqualQueryCycleDetailsDetailReq.setCycleTypeCode("DOUBLE_WEEKS");//CUSTOM_CONVENTION//sourceId:1058732_1_46134
queryTimeEqualQueryCycleDetailsDetailReq.setPlatformData("TRUE");//sourceId:1058734_1_46134
queryTimeEqualQueryCycleDetailsDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1058735_1_46134
if(circulationCollectionsRes!=null){
      queryTimeEqualQueryCycleDetailsDetailReq.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1058730_1_46134
queryTimeEqualQueryCycleDetailsDetailReq.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1058731_1_46134
    }

    /*3-4-04查询时间等于查周期详情详情[5379]   */
    Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getCycleStartTime(),"D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-周期开始时间不能为空",false);
Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getCycleEndTime(),"D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-周期结束时间不能为空",false);
Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getCycleTypeCode(),"D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-周期类型标识不能为空",false);
Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getPlatformData(),"D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-是否是平台不能为空",false);
Assert.isNull(queryTimeEqualQueryCycleDetailsDetailReq.getSubjectLifeCycle(),"D3-新增双周周期(公共)-3-4-04查询时间等于查周期详情详情-主体生命周期不能为空",false);
      omsCycle_2 = mOmsCycleService.queryTimeEqualQueryCycleDetailsDetail(queryTimeEqualQueryCycleDetailsDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsCycle_2 == null )) {
        //if(3-4-04查询周期是否存在.出参 值等于空 )  46135

GenerateTimeCycleEtcSemanticInstanceComRespDto generateTimeCycleEtcSemanticInstanceComRespDto = null;
    GenerateTimeCycleEtcSemanticInstanceComReqDto generateTimeCycleEtcSemanticInstanceComReqDto=new GenerateTimeCycleEtcSemanticInstanceComReqDto();
  generateTimeCycleEtcSemanticInstanceComReqDto.setTemplateSemanticEngineCode("GENERATE_IRREGULAR_CYCLE_NAME");//CUSTOM_CONVENTION//sourceId:1058747_1_46136
if(circulationCollectionsRes!=null){
      generateTimeCycleEtcSemanticInstanceComReqDto.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1058753_1_46136
generateTimeCycleEtcSemanticInstanceComReqDto.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1058754_1_46136
    }

    /*D2生成时间周期等语义内容服务(公共)[5030]   */
    Assert.isNull(generateTimeCycleEtcSemanticInstanceComReqDto.getTemplateSemanticEngineCode(),"D3-新增双周周期(公共)-D2生成时间周期等语义内容服务(公共)-模板引擎标识不能为空",false);
Assert.isNull(generateTimeCycleEtcSemanticInstanceComReqDto.getCycleStartTime(),"D3-新增双周周期(公共)-D2生成时间周期等语义内容服务(公共)-周期开始时间不能为空",false);
Assert.isNull(generateTimeCycleEtcSemanticInstanceComReqDto.getCycleEndTime(),"D3-新增双周周期(公共)-D2生成时间周期等语义内容服务(公共)-周期结束时间不能为空",false);
      generateTimeCycleEtcSemanticInstanceComRespDto = fwCompTemplateEngineClient.generateTimeCycleEtcSemanticInstanceCom(generateTimeCycleEtcSemanticInstanceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



String string = null;
    if(generateTimeCycleEtcSemanticInstanceComRespDto !=null){
          OmsCycle omsCycle_4=new OmsCycle();
  omsCycle_4.setCycleTypeName("双周");//CUSTOM_CONVENTION//sourceId:1058777_1_46137
omsCycle_4.setCycleSystemCode("YEAR");//sourceId:1058772_1_46137
omsCycle_4.setCycleTypeStandard("CUSTOM_STANDARD");//sourceId:1058773_1_46137
omsCycle_4.setPlatformData("TRUE");//sourceId:1058774_1_46137
omsCycle_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1058775_1_46137
if(generateTimeCycleEtcSemanticInstanceComRespDto!=null){
      omsCycle_4.setCycleStandardName(generateTimeCycleEtcSemanticInstanceComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1058768_1_46137
    }
if(circulationCollectionsRes!=null){
      omsCycle_4.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1058769_1_46137
omsCycle_4.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1058770_1_46137
omsCycle_4.setCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:1058771_1_46137
omsCycle_4.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1058778_1_46137
    }

    /*3-4-04新增周期[2001]   */
    Assert.isNull(omsCycle_4.getCycleStandardName(),"D3-新增双周周期(公共)-3-4-04新增周期-周期名称不能为空",false);
Assert.isNull(omsCycle_4.getCycleStartTime(),"D3-新增双周周期(公共)-3-4-04新增周期-周期开始时间不能为空",false);
Assert.isNull(omsCycle_4.getCycleEndTime(),"D3-新增双周周期(公共)-3-4-04新增周期-周期结束时间不能为空",false);
Assert.isNull(omsCycle_4.getCycleTypeCode(),"D3-新增双周周期(公共)-3-4-04新增周期-周期类型标识不能为空",false);
Assert.isNull(omsCycle_4.getCycleTypeName(),"D3-新增双周周期(公共)-3-4-04新增周期-周期类型名称不能为空",false);
Assert.isNull(omsCycle_4.getOrderNumber(),"D3-新增双周周期(公共)-3-4-04新增周期-排序不能为空",false);
Assert.isNull(omsCycle_4.getCycleSystemCode(),"D3-新增双周周期(公共)-3-4-04新增周期-周期体系类型标识不能为空",false);
Assert.isNull(omsCycle_4.getCycleTypeStandard(),"D3-新增双周周期(公共)-3-4-04新增周期-冗余周期类型标准化不能为空",false);
Assert.isNull(omsCycle_4.getPlatformData(),"D3-新增双周周期(公共)-3-4-04新增周期-是否是平台不能为空",false);
Assert.isNull(omsCycle_4.getSubjectLifeCycle(),"D3-新增双周周期(公共)-3-4-04新增周期-主体生命周期不能为空",false);
      string = mOmsCycleService.addCycle(omsCycle_4)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
//ModelCode: circulationEnd
        }

      }
AddCreateDoubleWeekCycleComRespDto retData = new AddCreateDoubleWeekCycleComRespDto();
  if(queryEvaObjTargetCycleDetailComRespDto_1!=null){
      retData.setTargetActualStartTime(queryEvaObjTargetCycleDetailComRespDto_1.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1860696_1
    }




return retData;
  }
/**
   * D3-查询执行周期对应目标周期详情(公共)[7299]
   * gen by moon at 10/1/2023, 12:28:10 PM
   */
  @Trace(operationName = "D3-查询执行周期对应目标周期详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryLastTargetCycleDetailComRespDto queryLastTargetCycleDetailCom(QueryLastTargetCycleDetailComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getIsProcessCycleStage() !=null && reqDto.getIsProcessCycleStage().equals("FALSE")&&reqDto!= null&&  reqDto.getIsSubCycle() !=null && reqDto.getIsSubCycle().equals("TRUE"))) {
        //if((D3-查询执行周期对应目标周期详情(公共).是否过程周期阶段 等于 否 and D3-查询执行周期对应目标周期详情(公共).是否子周期 等于 是))  47674

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:1088844_1_47678
queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1088850_1_47678
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1088839_1_47678
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1088840_1_47678
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1088841_1_47678
queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1088842_1_47678
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1088849_1_47678
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(omsEvaluationObjectTargetCycle !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      receptionServiceReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1089104_1_47679
    }

    /*约定出参：目标周期ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-查询执行周期对应目标周期详情(公共)-约定出参：目标周期ID-被评对象目标周期ID不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getIsProcessCycleStage() !=null && reqDto.getIsProcessCycleStage().equals("TRUE"))){
       //elseif(D3-查询执行周期对应目标周期详情(公共).是否过程周期阶段 等于 是)  47675

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsSubCycle("TRUE");//sourceId:1088844_1_47680
queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1088850_1_47680
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1088839_1_47680
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1088840_1_47680
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1088841_1_47680
queryEvaObjTargetCycleDetailReq_1.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1088846_1_47680
queryEvaObjTargetCycleDetailReq_1.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1088847_1_47680
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1088849_1_47680
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsSubCycle(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(),"D3-查询执行周期对应目标周期详情(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  if(omsEvaluationObjectTargetCycle_2!=null){
      receptionServiceReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1089104_1_47681
    }

    /*约定出参：目标周期ID[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getEvaObjTargetCycleId(),"D3-查询执行周期对应目标周期详情(公共)-约定出参：目标周期ID-被评对象目标周期ID不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.calculateAcceptAboveFields(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
QueryLastTargetCycleDetailComRespDto retData = new QueryLastTargetCycleDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1089122_1
    }




return retData;
  }
/**
   * D3执行补偿目标内容父或中周期自定义周期(公共)[9379]
   * gen by moon at 4/15/2024, 1:33:59 AM
   */
  @Trace(operationName = "D3执行补偿目标内容父或中周期自定义周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComRespDto implementCompensateTargetContFatherOrMidCycleCustExeCycleCom(ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComReqDto reqDto){


      //virtualUsage D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）  66729
      ObtainEvaObjTargetCycleComRespDto obtainEvaObjTargetCycleComRespDto = null;
    ObtainEvaObjTargetCycleComReqDto obtainEvaObjTargetCycleComReqDto=new ObtainEvaObjTargetCycleComReqDto();
  obtainEvaObjTargetCycleComReqDto.setIsArchive("FALSE");//sourceId:1724327_1_66729
if(reqDto!=null){
      obtainEvaObjTargetCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1724314_1_66729
obtainEvaObjTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1724316_1_66729
obtainEvaObjTargetCycleComReqDto.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1724318_1_66729
obtainEvaObjTargetCycleComReqDto.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1724343_1_66729
obtainEvaObjTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1724325_1_66729
    }

    /*D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）[9380]   */
    Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaObjTypeCode(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-被评对象类型编码不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getTargetCycleContentId(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-关联目标内容ID不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getEvaluationTemplateId(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-冗余评价模板ID不能为空",false);
Assert.isNull(obtainEvaObjTargetCycleComReqDto.getIsArchive(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D3查询目标被评对象父或中周期周期类型（用于与目标内容比对是否相同）-是否存档不能为空",false);
      obtainEvaObjTargetCycleComRespDto = targetCycleService.obtainEvaObjTargetCycleCom(obtainEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D2入参周期类型标识与目标父周期类型标识比较（判断是否相同）  66730
      ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
    if(obtainEvaObjTargetCycleComRespDto !=null){
          ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto=new ImplementStringEfficiencyCheckComReqDto();
  if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1724162_1_66730
    }
if(obtainEvaObjTargetCycleComRespDto!=null){
      implementStringEfficiencyCheckComReqDto.setComparisonString(obtainEvaObjTargetCycleComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1724163_1_66730
    }

    /*D2入参周期类型标识与目标父周期类型标识比较（判断是否相同）[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D2入参周期类型标识与目标父周期类型标识比较（判断是否相同）-参照字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))) {
        //if(D2入参周期类型标识与目标父或中周期类型标识比较（判断是否相同）.字符串对比结果 等于 否)  66731

ImplementAddTargetContExecuteCycleComRespDto implementAddTargetContExecuteCycleComRespDto = null;
    ImplementAddTargetContExecuteCycleComReqDto implementAddTargetContExecuteCycleComReqDto=new ImplementAddTargetContExecuteCycleComReqDto();
  if(reqDto!=null){
      implementAddTargetContExecuteCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1724160_1_66732
implementAddTargetContExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1724159_1_66732
    }

    /*D3新增目标内容父周期自定义执行周期(公共)[6527]   */
    Assert.isNull(implementAddTargetContExecuteCycleComReqDto.getEvaObjTargetCycleId(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D3新增目标内容父周期自定义执行周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAddTargetContExecuteCycleComReqDto.getEvaluationTemplateId(),"D3执行补偿目标内容父或中周期自定义周期(公共)-D3新增目标内容父周期自定义执行周期(公共)-冗余评价模板ID不能为空",false);
      implementAddTargetContExecuteCycleComRespDto = targetContentService.implementAddTargetContExecuteCycleCom(implementAddTargetContExecuteCycleComReqDto)/*vcase invoke isSameApp*/;



      }
ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComRespDto retData = new ImplementCompensateTargetContFatherOrMidCycleCustExeCycleComRespDto();





return retData;
  }
/**
   * D3新增目标内容过程执行周期阶段(公共)[9382]
   * gen by moon at 6/22/2024, 12:20:52 PM
   */
  @Trace(operationName = "D3新增目标内容过程执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddTargetConProgressExecuteCycleComRespDto addTargetConProgressExecuteCycleCom(AddTargetConProgressExecuteCycleComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getSubCycleList() !=null && reqDto.getSubCycleList().size()>0)) {
        //if(D3新增目标内容过程执行周期阶段(公共).子周期列表数据集条数 大于 0)  66740

//ModelCode: circulationCollections
        for (SubCycleDto circulationCollectionsRes: reqDto.getSubCycleList()){

AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto analysisTargetContentCustomProcessExecutionCycleRangeComRespDto = null;
    AnalysisTargetContentCustomProcessExecutionCycleRangeComReqDto analysisTargetContentCustomProcessExecutionCycleRangeComReqDto=new AnalysisTargetContentCustomProcessExecutionCycleRangeComReqDto();
if(circulationCollectionsRes!=null){
      analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1880507_1_70446
analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1880508_1_70446
analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1880509_1_70446
analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetActualEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1880510_1_70446
    }
if(reqDto!=null){
      analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1880511_1_70446
analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1880513_1_70446
analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880512_1_70446
    }

    /*D3分析目标内容自定义过程执行周期范围(公共)[9835]   */
    Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getEvaObjTargetCycleId(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getCycleId(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-周期ID不能为空",false);
Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetActualStartTime(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-成果汇报开始时间不能为空",false);
Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetActualEndtTime(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-成果汇报结束时间不能为空",false);
Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetCycleContentId(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getTargetId(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-冗余目标ID不能为空",false);
Assert.isNull(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto.getEvaluationTemplateId(),"D3新增目标内容过程执行周期阶段(公共)-D3分析目标内容自定义过程执行周期范围(公共)-冗余评价模板ID不能为空",false);
      analysisTargetContentCustomProcessExecutionCycleRangeComRespDto = analysisTargetContentCustomProcessExecutionCycleRangeCom(analysisTargetContentCustomProcessExecutionCycleRangeComReqDto)/*vcase invoke 同服务,同domain*/;



LoopUpdateTargetConExecuteCycleStageComRespDto loopUpdateTargetConExecuteCycleStageComRespDto = null;
    if(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto !=null){
          LoopUpdateTargetConExecuteCycleStageComReqDto loopUpdateTargetConExecuteCycleStageComReqDto=new LoopUpdateTargetConExecuteCycleStageComReqDto();
  if(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto!= null&&  analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList())){
      loopUpdateTargetConExecuteCycleStageComReqDto.setExecuteCycleStageList(//objList-to-objLists
        analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList().stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
if(item!=null){
      elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:347662_2_66799
elm.setRelateExecuteCycleStageId(item.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:345859_2_66799
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:345828_2_66799
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:345829_2_66799
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:345830_2_66799
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:345831_2_66799
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:345832_2_66799
elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:345833_2_66799
elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:345835_2_66799
elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:345836_2_66799
elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:345837_2_66799
elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:345838_2_66799
elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:345839_2_66799
elm.setIsDefinedExecuteCycleStage(item.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:345840_2_66799
elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:345842_2_66799
elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:345843_2_66799
elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:345844_2_66799
elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:345845_2_66799
elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:345846_2_66799
elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:345847_2_66799
elm.setEvaObjTargetCycleId(item.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:345848_2_66799
elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:345849_2_66799
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:345851_2_66799
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:345850_2_66799
elm.setRelateContentTypeCode(item.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:345852_2_66799
elm.setRelateContentId(item.getRelateContentId());//SimpleFieldAssign//sourceId:345853_2_66799
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:345856_2_66799
elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:345857_2_66799
    }
if(reqDto!=null){
elm.setTargetId(reqDto.getTargetId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:345854_2_66799
elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:345855_2_66799
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1728290_1_66799
    }

    /*D3循环更新目标内容执行周期阶段(公共)[9388]   */

      loopUpdateTargetConExecuteCycleStageComRespDto = loopUpdateTargetConExecuteCycleStageCom(loopUpdateTargetConExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementModifyStartOrEndDefinedExecCycleComRespDto implementModifyStartOrEndDefinedExecCycleComRespDto = null;
    if(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto !=null){
          ImplementModifyStartOrEndDefinedExecCycleComReqDto implementModifyStartOrEndDefinedExecCycleComReqDto=new ImplementModifyStartOrEndDefinedExecCycleComReqDto();
  implementModifyStartOrEndDefinedExecCycleComReqDto.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1887116_1_70600
implementModifyStartOrEndDefinedExecCycleComReqDto.setIsProcessCycleStage("TRUE");//sourceId:1887117_1_70600
if(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto!=null){
      implementModifyStartOrEndDefinedExecCycleComReqDto.setExecuteCycleStageList(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getSubCycleStartTimeExecuteCycleStageList());//list-field-assign//sourceId:1887114_1_70600
    }
if(circulationCollectionsRes!=null){
      implementModifyStartOrEndDefinedExecCycleComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1887119_1_70600
implementModifyStartOrEndDefinedExecCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887115_1_70600
    }
if(reqDto!=null){
      implementModifyStartOrEndDefinedExecCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887118_1_70600
    }

    /*D3执行修正子周期开始或结束的自定义过程执行周期(公共)[9847]   */
    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getEvaObjTargetCycleId(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getIsDefinedExecuteCycleStage(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getIsProcessCycleStage(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否过程周期阶段不能为空",false);
Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto.getEvaluationTemplateId(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-冗余评价模板ID不能为空",false);
      implementModifyStartOrEndDefinedExecCycleComRespDto = implementModifyStartOrEndDefinedExecCycleCom(implementModifyStartOrEndDefinedExecCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementModifyStartOrEndDefinedExecCycleComRespDto implementModifyStartOrEndDefinedExecCycleComRespDto_1 = null;
    if(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto !=null){
          ImplementModifyStartOrEndDefinedExecCycleComReqDto implementModifyStartOrEndDefinedExecCycleComReqDto_1=new ImplementModifyStartOrEndDefinedExecCycleComReqDto();
  implementModifyStartOrEndDefinedExecCycleComReqDto_1.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1887116_1_70601
implementModifyStartOrEndDefinedExecCycleComReqDto_1.setIsProcessCycleStage("TRUE");//sourceId:1887117_1_70601
if(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto!=null){
      implementModifyStartOrEndDefinedExecCycleComReqDto_1.setExecuteCycleStageList(analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getSubCycleEndTimeExecuteCycleStageList());//list-field-assign//sourceId:1887114_1_70601
    }
if(circulationCollectionsRes!=null){
      implementModifyStartOrEndDefinedExecCycleComReqDto_1.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1887120_1_70601
implementModifyStartOrEndDefinedExecCycleComReqDto_1.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887115_1_70601
    }
if(reqDto!=null){
      implementModifyStartOrEndDefinedExecCycleComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887118_1_70601
    }

    /*D3执行修正子周期开始或结束的自定义过程执行周期(公共)[9847]   */
    Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getEvaObjTargetCycleId(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getIsDefinedExecuteCycleStage(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getIsProcessCycleStage(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-是否过程周期阶段不能为空",false);
Assert.isNull(implementModifyStartOrEndDefinedExecCycleComReqDto_1.getEvaluationTemplateId(),"D3新增目标内容过程执行周期阶段(公共)-D3执行修正子周期开始或结束的自定义过程执行周期(公共)-冗余评价模板ID不能为空",false);
      implementModifyStartOrEndDefinedExecCycleComRespDto_1 = implementModifyStartOrEndDefinedExecCycleCom(implementModifyStartOrEndDefinedExecCycleComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
if((analysisTargetContentCustomProcessExecutionCycleRangeComRespDto!= null&&  analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList() !=null && analysisTargetContentCustomProcessExecutionCycleRangeComRespDto.getExecuteCycleStageList().size()>0)) {
        //if(D3分析目标内容自定义过程执行周期范围(公共).执行周期阶段列表数据集条数 大于 0)  66808

boolean bOOLEAN ;
    OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle=new OmsEvaluationObjectTargetCycle();
  omsEvaluationObjectTargetCycle.setHaveProcessCycle("TRUE");//sourceId:1728787_1_66809
if(circulationCollectionsRes!=null){
      omsEvaluationObjectTargetCycle.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1728786_1_66809
    }

    /*3-3-09修改被评对象目标周期[2317]   */
    Assert.isNull(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId(),"D3新增目标内容过程执行周期阶段(公共)-3-3-09修改被评对象目标周期-被评对象目标周期ID不能为空",false);
Assert.isNull(omsEvaluationObjectTargetCycle.getHaveProcessCycle(),"D3新增目标内容过程执行周期阶段(公共)-3-3-09修改被评对象目标周期-是否有过程周期不能为空",false);
      bOOLEAN = mOmsEvaluationObjectTargetCycleService.updateEvaObjTargetCycle(omsEvaluationObjectTargetCycle)/*vcase invoke 本地 method 方法调用;*/;



      }
//ModelCode: circulationEnd
        }

      }
AddTargetConProgressExecuteCycleComRespDto retData = new AddTargetConProgressExecuteCycleComRespDto();





return retData;
  }
/**
   * D3新增目标内容工作周期执行周期阶段(公共)[9385]
   * gen by moon at 4/16/2024, 7:15:22 PM
   */
  @Trace(operationName = "D3新增目标内容工作周期执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddTargetConWorkExecuteCycleComRespDto addTargetConWorkExecuteCycleCom(AddTargetConWorkExecuteCycleComReqDto reqDto){


      //virtualUsage D3-3查询被评对象目标周期列表(公共)  66765
      QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
    QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto=new QueryEvaObjTargetCycleListComReqDto();
queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1725874_1_66765
if(reqDto!=null){
      queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1725869_1_66765
queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1725870_1_66765
queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1725872_1_66765
queryEvaObjTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1725875_1_66765
    }

    /*D3-3查询被评对象目标周期列表(公共)[3451]   */
    Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(),"D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(),"D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaluationTemplateId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-冗余评价模板ID不能为空",false);
      queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



if((queryEvaObjTargetCycleListComRespDto!= null&&  queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3-3查询被评对象目标周期列表（父、子、中工作周期）.被评对象目标周期列表数据集条数 大于 0)  66766

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()){

AddTargetContenteExecutionCycleComRespDto addTargetContenteExecutionCycleComRespDto = null;
    AddTargetContenteExecutionCycleComReqDto addTargetContenteExecutionCycleComReqDto=new AddTargetContenteExecutionCycleComReqDto();
  addTargetContenteExecutionCycleComReqDto.setIsProcessCycleStage("FALSE");//sourceId:1728300_1_66801
addTargetContenteExecutionCycleComReqDto.setIsCurrentCycle("FALSE");//sourceId:1728307_1_66801
addTargetContenteExecutionCycleComReqDto.setIsNextCycle("FALSE");//sourceId:1728308_1_66801
addTargetContenteExecutionCycleComReqDto.setIsStartCycle("FALSE");//sourceId:1728309_1_66801
addTargetContenteExecutionCycleComReqDto.setIsEndCycle("FALSE");//sourceId:1728310_1_66801
addTargetContenteExecutionCycleComReqDto.setIsLastCycle("FALSE");//sourceId:1728315_1_66801
if(circulationCollectionsRes!=null){
      addTargetContenteExecutionCycleComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1728292_1_66801
addTargetContenteExecutionCycleComReqDto.setCycleStandardName(circulationCollectionsRes.getCycleStandardName());//SimpleFieldAssign//sourceId:1728322_1_66801
addTargetContenteExecutionCycleComReqDto.setCycleStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1728293_1_66801
addTargetContenteExecutionCycleComReqDto.setCycleEndTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1728294_1_66801
addTargetContenteExecutionCycleComReqDto.setCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:1728295_1_66801
addTargetContenteExecutionCycleComReqDto.setCycleTypeInstanceCode(circulationCollectionsRes.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1728296_1_66801
addTargetContenteExecutionCycleComReqDto.setFillStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1728302_1_66801
addTargetContenteExecutionCycleComReqDto.setFillEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1728303_1_66801
addTargetContenteExecutionCycleComReqDto.setEvaluateStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1728304_1_66801
addTargetContenteExecutionCycleComReqDto.setEvaluateEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1728305_1_66801
addTargetContenteExecutionCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1728291_1_66801
addTargetContenteExecutionCycleComReqDto.setIsParentCycle(circulationCollectionsRes.getIsParentCycle());//SimpleFieldAssign//sourceId:1728297_1_66801
addTargetContenteExecutionCycleComReqDto.setIsMetaphase(circulationCollectionsRes.getIsMetaphase());//SimpleFieldAssign//sourceId:1728298_1_66801
addTargetContenteExecutionCycleComReqDto.setIsSubCycle(circulationCollectionsRes.getIsSubCycle());//SimpleFieldAssign//sourceId:1728299_1_66801
addTargetContenteExecutionCycleComReqDto.setEvaTempCreateTime(circulationCollectionsRes.getSortCreateTime());//SimpleFieldAssign//sourceId:1728318_1_66801
addTargetContenteExecutionCycleComReqDto.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1728317_1_66801
addTargetContenteExecutionCycleComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1728311_1_66801
addTargetContenteExecutionCycleComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1728312_1_66801
    }
if(reqDto!=null){
      addTargetContenteExecutionCycleComReqDto.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1728301_1_66801
addTargetContenteExecutionCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1728313_1_66801
addTargetContenteExecutionCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1728314_1_66801
    }

    /*D3新增目标内容执行周期(公共)[9386]   */
    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getPeriodId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStandardName(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期名称不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStartTime(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期开始时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleEndTime(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期结束时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleTypeCode(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期类型标识不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillStartTime(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报开始时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillEndtTime(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报结束时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsProcessCycleStage(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否过程周期阶段不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsDefinedExecuteCycleStage(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsCurrentCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期当前不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsNextCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期下一个不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsStartCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否开始子周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsEndCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否截止子周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsLastCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaObjTargetCycleId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsParentCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否父周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsMetaphase(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否中期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsSubCycle(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否子周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaTempCreateTime(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-评价模板创建时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getOrderNumber(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期排序不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentTypeCode(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaluationTemplateId(),"D3新增目标内容工作周期执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余评价模板ID不能为空",false);
      addTargetContenteExecutionCycleComRespDto = addTargetContenteExecutionCycleCom(addTargetContenteExecutionCycleComReqDto)/*vcase invoke 同服务,同domain*/;



//ModelCode: circulationEnd
        }

      }
AddTargetConWorkExecuteCycleComRespDto retData = new AddTargetConWorkExecuteCycleComRespDto();





return retData;
  }
/**
   * D3新增目标内容执行周期(公共)[9386]
   * gen by moon at 5/7/2024, 11:20:45 PM
   */
  @Trace(operationName = "D3新增目标内容执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddTargetContenteExecutionCycleComRespDto addTargetContenteExecutionCycleCom(AddTargetContenteExecutionCycleComReqDto reqDto){


      String string_1 =null;
//virtualUsage 3-3-07查询执行周期阶段详情  66771
      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1726051_1_66771
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1739250_1_66771
      queryExecuteCycleStageDetailReq.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1726048_1_66771
queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1726049_1_66771
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1726050_1_66771
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(),"D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空",false);
    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(),"D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3新增目标内容执行周期(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsExecuteCycleStage == null )) {
        //if(3-3-07查询执行周期阶段详情.出参 值等于空 )  66775

String string = null;
    OmsExecuteCycleStage omsExecuteCycleStage_2=new OmsExecuteCycleStage();
  if(reqDto!=null){
      omsExecuteCycleStage_2.setLastExecuteCycleStageId(reqDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728228_1_66778
omsExecuteCycleStage_2.setRelateExecuteCycleStageId(reqDto.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728229_1_66778
omsExecuteCycleStage_2.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1725990_1_66778
omsExecuteCycleStage_2.setCycleStandardName(reqDto.getCycleStandardName());//SimpleFieldAssign//sourceId:1726011_1_66778
omsExecuteCycleStage_2.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1726012_1_66778
omsExecuteCycleStage_2.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1726013_1_66778
omsExecuteCycleStage_2.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1726014_1_66778
omsExecuteCycleStage_2.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1726020_1_66778
omsExecuteCycleStage_2.setFillStartTime(reqDto.getFillStartTime());//SimpleFieldAssign//sourceId:1726006_1_66778
omsExecuteCycleStage_2.setFillEndtTime(reqDto.getFillEndtTime());//SimpleFieldAssign//sourceId:1726007_1_66778
omsExecuteCycleStage_2.setEvaluateStartTime(reqDto.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1726008_1_66778
omsExecuteCycleStage_2.setEvaluateEndtTime(reqDto.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1726009_1_66778
omsExecuteCycleStage_2.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1725996_1_66778
omsExecuteCycleStage_2.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1725997_1_66778
omsExecuteCycleStage_2.setIsSameSceneCurrentSubCycle(reqDto.getIsSameSceneCurrentSubCycle());//SimpleFieldAssign//sourceId:1728230_1_66778
omsExecuteCycleStage_2.setIsCurrentCycle(reqDto.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1726016_1_66778
omsExecuteCycleStage_2.setIsNextCycle(reqDto.getIsNextCycle());//SimpleFieldAssign//sourceId:1726017_1_66778
omsExecuteCycleStage_2.setIsStartCycle(reqDto.getIsStartCycle());//SimpleFieldAssign//sourceId:1726001_1_66778
omsExecuteCycleStage_2.setIsEndCycle(reqDto.getIsEndCycle());//SimpleFieldAssign//sourceId:1726002_1_66778
omsExecuteCycleStage_2.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1726003_1_66778
omsExecuteCycleStage_2.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1726019_1_66778
omsExecuteCycleStage_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1726018_1_66778
omsExecuteCycleStage_2.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1725993_1_66778
omsExecuteCycleStage_2.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1725995_1_66778
omsExecuteCycleStage_2.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1725994_1_66778
omsExecuteCycleStage_2.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1725998_1_66778
omsExecuteCycleStage_2.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1725999_1_66778
omsExecuteCycleStage_2.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1726005_1_66778
omsExecuteCycleStage_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1726000_1_66778
omsExecuteCycleStage_2.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:1725992_1_66778
omsExecuteCycleStage_2.setEvaTempCreateTime(reqDto.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1725991_1_66778
    }

    /*3-3-07新增执行周期阶段[2354]   */
    Assert.isNull(omsExecuteCycleStage_2.getCycleId(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleStandardName(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期名称不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleStartTime(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleEndTime(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getCycleTypeCode(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期类型标识不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getFillStartTime(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getFillEndtTime(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsProcessCycleStage(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否过程周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsDefinedExecuteCycleStage(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否自定义执行周期阶段不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsStartCycle(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否开始子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsEndCycle(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否截止子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsLastCycle(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否末级周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaObjTargetCycleId(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-被评对象目标周期ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsFatherCycle(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否父周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsMetaphase(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否中期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getIsSubCycle(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-是否子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getRelateContentTypeCode(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容类型编码不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getRelateContentId(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-关联目标内容ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getTargetId(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-冗余目标ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaluationTemplateId(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-评价模板ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getOrderNumber(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-周期排序不能为空",false);
Assert.isNull(omsExecuteCycleStage_2.getEvaTempCreateTime(),"D3新增目标内容执行周期(公共)-3-3-07新增执行周期阶段-评价模板创建时间不能为空",false);
      string = mOmsExecuteCycleStageService.addExecuteCycleStage(omsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;


      string_1 = string;
      }
else if((omsExecuteCycleStage != null )){
       //elseif(3-3-07查执行周期阶段是否存在.出参 值不等于空 )  66776

boolean bOOLEAN ;
    if(omsExecuteCycleStage !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_3=new OmsExecuteCycleStage();
  if(reqDto!=null){
      omsExecuteCycleStage_3.setLastExecuteCycleStageId(reqDto.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728258_1_66777
omsExecuteCycleStage_3.setRelateExecuteCycleStageId(reqDto.getRelateExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728259_1_66777
omsExecuteCycleStage_3.setCycleId(reqDto.getPeriodId());//SimpleFieldAssign//sourceId:1728281_1_66777
omsExecuteCycleStage_3.setCycleStandardName(reqDto.getCycleStandardName());//SimpleFieldAssign//sourceId:1728282_1_66777
omsExecuteCycleStage_3.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1728261_1_66777
omsExecuteCycleStage_3.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1728260_1_66777
omsExecuteCycleStage_3.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1728283_1_66777
omsExecuteCycleStage_3.setCycleTypeInstanceCode(reqDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1728284_1_66777
omsExecuteCycleStage_3.setFillStartTime(reqDto.getFillStartTime());//SimpleFieldAssign//sourceId:1727477_1_66777
omsExecuteCycleStage_3.setFillEndtTime(reqDto.getFillEndtTime());//SimpleFieldAssign//sourceId:1727478_1_66777
omsExecuteCycleStage_3.setEvaluateStartTime(reqDto.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1727479_1_66777
omsExecuteCycleStage_3.setEvaluateEndtTime(reqDto.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1727480_1_66777
omsExecuteCycleStage_3.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1728272_1_66777
omsExecuteCycleStage_3.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1728285_1_66777
omsExecuteCycleStage_3.setIsSameSceneCurrentSubCycle(reqDto.getIsSameSceneCurrentSubCycle());//SimpleFieldAssign//sourceId:1728286_1_66777
omsExecuteCycleStage_3.setIsCurrentCycle(reqDto.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1728263_1_66777
omsExecuteCycleStage_3.setIsNextCycle(reqDto.getIsNextCycle());//SimpleFieldAssign//sourceId:1728265_1_66777
omsExecuteCycleStage_3.setIsStartCycle(reqDto.getIsStartCycle());//SimpleFieldAssign//sourceId:1728264_1_66777
omsExecuteCycleStage_3.setIsEndCycle(reqDto.getIsEndCycle());//SimpleFieldAssign//sourceId:1728266_1_66777
omsExecuteCycleStage_3.setIsLastCycle(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1728267_1_66777
omsExecuteCycleStage_3.setNextCyclePeriod(reqDto.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1728271_1_66777
omsExecuteCycleStage_3.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1728257_1_66777
omsExecuteCycleStage_3.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1728268_1_66777
omsExecuteCycleStage_3.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1728270_1_66777
omsExecuteCycleStage_3.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1728269_1_66777
omsExecuteCycleStage_3.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1728273_1_66777
omsExecuteCycleStage_3.setOrderNumber(reqDto.getOrderNumber());//SimpleFieldAssign//sourceId:1728287_1_66777
    }
if(omsExecuteCycleStage!=null){
      omsExecuteCycleStage_3.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1727476_1_66777
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_3.getExecuteCycleStageId(),"D3新增目标内容执行周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
      bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
AddTargetContenteExecutionCycleComRespDto retData = new AddTargetContenteExecutionCycleComRespDto();
  if(string_1!=null){
      retData.setExecuteCycleStageId(string_1);//SimpleFieldAssign//sourceId:1728288_1
    }




return retData;
  }
/**
   * D3新增目标内容执行周期阶段(公共)[9387]
   * gen by moon at 5/7/2024, 6:22:54 PM
   */
  @Trace(operationName = "D3新增目标内容执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AddTargetConExecuteCycleStageComRespDto addTargetConExecuteCycleStageCom(AddTargetConExecuteCycleStageComReqDto reqDto){


      //virtualUsage D3准备目标内容扩展信息(公共)  66783
      PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
    PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto=new PreparationTargetContExtendInfoComReqDto();
  if(reqDto!=null){
      preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1727381_1_66783
preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1727382_1_66783
preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727383_1_66783
    }

    /*D3准备目标内容扩展信息(公共)[8590]   */
    Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(),"D3新增目标内容执行周期阶段(公共)-D3准备目标内容扩展信息(公共)-关联目标内容ID不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(),"D3新增目标内容执行周期阶段(公共)-D3准备目标内容扩展信息(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(),"D3新增目标内容执行周期阶段(公共)-D3准备目标内容扩展信息(公共)-冗余评价模板ID不能为空",false);
      preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;



if((preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_PORTRAIT"))||(preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("EVA_OBJECT"))||(preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE")&&preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsCustomObjective() !=null && preparationTargetContExtendInfoComRespDto.getIsCustomObjective().equals("TRUE")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))||(preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle() !=null && preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle().equals("TRUE")&&preparationTargetContExtendInfoComRespDto!= null&&  preparationTargetContExtendInfoComRespDto.getIndicatorKind() !=null && preparationTargetContExtendInfoComRespDto.getIndicatorKind().equals("KEY_RESULTS")&&reqDto!= null&&  reqDto.getEvaObjTypeCode() !=null && reqDto.getEvaObjTypeCode().equals("OKR_SUBJECT_PERSONAL"))) {
        //if((D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 评价画像) or (D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 评价对象) or (D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3准备目标内容扩展信息(公共).是否自定义OKR目标 等于 是 and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 OKR责任主体个人) or (D3准备目标内容扩展信息(公共).是否开启自定义执行周期 等于 是 and D3准备目标内容扩展信息(公共).OKR目标属性 等于 关键成果KR and D3新增目标内容执行周期阶段(公共).被评对象类型编码 等于 OKR责任主体个人))  66784

AddTargetConWorkExecuteCycleComRespDto addTargetConWorkExecuteCycleComRespDto = null;
    AddTargetConWorkExecuteCycleComReqDto addTargetConWorkExecuteCycleComReqDto=new AddTargetConWorkExecuteCycleComReqDto();
  addTargetConWorkExecuteCycleComReqDto.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1728791_1_66785
if(reqDto!=null){
      addTargetConWorkExecuteCycleComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1733246_1_66785
addTargetConWorkExecuteCycleComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1733245_1_66785
      addTargetConWorkExecuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1727046_1_66785
addTargetConWorkExecuteCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1728792_1_66785
addTargetConWorkExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727048_1_66785
addTargetConWorkExecuteCycleComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1727049_1_66785
    }

    /*D3新增目标内容工作周期执行周期阶段(公共)[9385]   */
    Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getEvaObjEntityId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getEvaObjTypeCode(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-被评对象类型编码不能为空",false);
    Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getTargetCycleContentId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getIsDefinedExecuteCycleStage(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getTargetId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-冗余目标ID不能为空",false);
Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getEvaluationTemplateId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(addTargetConWorkExecuteCycleComReqDto.getSpaceId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容工作周期执行周期阶段(公共)-创建于空间ID不能为空",false);
      addTargetConWorkExecuteCycleComRespDto = addTargetConWorkExecuteCycleCom(addTargetConWorkExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementTargetConSubExecuteCycleStageComRespDto implementTargetConSubExecuteCycleStageComRespDto = null;
    ImplementTargetConSubExecuteCycleStageComReqDto implementTargetConSubExecuteCycleStageComReqDto=new ImplementTargetConSubExecuteCycleStageComReqDto();
  if(reqDto!=null){
      implementTargetConSubExecuteCycleStageComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1733255_1_66888
implementTargetConSubExecuteCycleStageComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1733256_1_66888
      implementTargetConSubExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1731358_1_66888
implementTargetConSubExecuteCycleStageComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1731361_1_66888
implementTargetConSubExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731359_1_66888
implementTargetConSubExecuteCycleStageComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1731360_1_66888
    }

    /*D3执行回写目标内容子周期执行周期阶段(公共)[9392]   */
    Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getEvaObjEntityId(),"D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getEvaObjTypeCode(),"D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-被评对象类型编码不能为空",false);
    Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getTargetCycleContentId(),"D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getTargetId(),"D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-冗余目标ID不能为空",false);
Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementTargetConSubExecuteCycleStageComReqDto.getSpaceId(),"D3新增目标内容执行周期阶段(公共)-D3执行回写目标内容子周期执行周期阶段(公共)-创建于空间ID不能为空",false);
      implementTargetConSubExecuteCycleStageComRespDto = implementTargetConSubExecuteCycleStageCom(implementTargetConSubExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;



RefreshTargetConParentAndMidExecuteCycleStageComRespDto refreshTargetConParentAndMidExecuteCycleStageComRespDto = null;
    RefreshTargetConParentAndMidExecuteCycleStageComReqDto refreshTargetConParentAndMidExecuteCycleStageComReqDto=new RefreshTargetConParentAndMidExecuteCycleStageComReqDto();
  refreshTargetConParentAndMidExecuteCycleStageComReqDto.setIsMetaphase("TRUE");//sourceId:1731349_1_66889
refreshTargetConParentAndMidExecuteCycleStageComReqDto.setIsSubCycle("FALSE");//sourceId:1732593_1_66889
if(reqDto!=null){
      refreshTargetConParentAndMidExecuteCycleStageComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1731345_1_66889
refreshTargetConParentAndMidExecuteCycleStageComReqDto.setSubcycleType(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1736176_1_66889
refreshTargetConParentAndMidExecuteCycleStageComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731346_1_66889
    }

    /*D3更新目标内容中周期执行周期阶段(公共)[9393]   */
    Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getTargetCycleContentId(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getIsMetaphase(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-是否中期不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getIsSubCycle(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-是否子周期不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getSubcycleType(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-子周期周期类型不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto.getEvaluationTemplateId(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容中周期执行周期阶段(公共)-冗余评价模板ID不能为空",false);
      refreshTargetConParentAndMidExecuteCycleStageComRespDto = refreshTargetConParentAndMidExecuteCycleStageCom(refreshTargetConParentAndMidExecuteCycleStageComReqDto)/*vcase invoke 同服务,同domain*/;



RefreshTargetConParentAndMidExecuteCycleStageComRespDto refreshTargetConParentAndMidExecuteCycleStageComRespDto_2 = null;
    RefreshTargetConParentAndMidExecuteCycleStageComReqDto refreshTargetConParentAndMidExecuteCycleStageComReqDto_1=new RefreshTargetConParentAndMidExecuteCycleStageComReqDto();
  refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setIsParentCycle("TRUE");//sourceId:1731356_1_66890
refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setIsSubCycle("FALSE");//sourceId:1732592_1_66890
if(reqDto!=null){
      refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1731353_1_66890
refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setSubcycleType(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1736175_1_66890
refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731354_1_66890
    }

    /*D3更新目标内容父周期执行周期阶段(公共)[9393]   */
    Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getTargetCycleContentId(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getIsParentCycle(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-是否父周期不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getIsSubCycle(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-是否子周期不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getSubcycleType(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-子周期周期类型不能为空",false);
Assert.isNull(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1.getEvaluationTemplateId(),"D3新增目标内容执行周期阶段(公共)-D3更新目标内容父周期执行周期阶段(公共)-冗余评价模板ID不能为空",false);
      refreshTargetConParentAndMidExecuteCycleStageComRespDto_2 = refreshTargetConParentAndMidExecuteCycleStageCom(refreshTargetConParentAndMidExecuteCycleStageComReqDto_1)/*vcase invoke 同服务,同domain*/;



AddTargetConProgressExecuteCycleComRespDto addTargetConProgressExecuteCycleComRespDto = null;
    if(implementTargetConSubExecuteCycleStageComRespDto !=null){
          AddTargetConProgressExecuteCycleComReqDto addTargetConProgressExecuteCycleComReqDto=new AddTargetConProgressExecuteCycleComReqDto();
  if(implementTargetConSubExecuteCycleStageComRespDto!= null&&  implementTargetConSubExecuteCycleStageComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(implementTargetConSubExecuteCycleStageComRespDto.getEvaObjTargetCycleList())){
      addTargetConProgressExecuteCycleComReqDto.setSubCycleList(implementTargetConSubExecuteCycleStageComRespDto.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, SubCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1727041_1_66786
    }
if(reqDto!=null){
      addTargetConProgressExecuteCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1784090_1_66786
      addTargetConProgressExecuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1727045_1_66786
addTargetConProgressExecuteCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1727042_1_66786
addTargetConProgressExecuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727043_1_66786
    }

    /*D3新增目标内容过程执行周期阶段(公共)[9382]   */
    Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getTargetCycleContentTypeCode(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-关联目标内容类型编码不能为空",false);
    Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getTargetCycleContentId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getTargetId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-冗余目标ID不能为空",false);
Assert.isNull(addTargetConProgressExecuteCycleComReqDto.getEvaluationTemplateId(),"D3新增目标内容执行周期阶段(公共)-D3新增目标内容过程执行周期阶段(公共)-冗余评价模板ID不能为空",false);
      addTargetConProgressExecuteCycleComRespDto = addTargetConProgressExecuteCycleCom(addTargetConProgressExecuteCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }
      }
AddTargetConExecuteCycleStageComRespDto retData = new AddTargetConExecuteCycleStageComRespDto();





return retData;
  }
/**
   * D3循环更新目标内容执行周期阶段(公共)[9388]
   * gen by moon at 7/10/2024, 6:45:04 PM
   */
  @Trace(operationName = "D3循环更新目标内容执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public LoopUpdateTargetConExecuteCycleStageComRespDto loopUpdateTargetConExecuteCycleStageCom(LoopUpdateTargetConExecuteCycleStageComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null && reqDto.getExecuteCycleStageList().size()>0)) {
        //if(D3循环更新目标内容执行周期阶段(公共).执行周期阶段列表数据集条数 大于 0)  66789

//ModelCode: circulationCollections
        for (ExecuteCycleStageDto circulationCollectionsRes: reqDto.getExecuteCycleStageList()){

ObtainPreProgressExecuteCycleStageIdComRespDto obtainPreProgressExecuteCycleStageIdComRespDto = null;
    ObtainPreProgressExecuteCycleStageIdComReqDto obtainPreProgressExecuteCycleStageIdComReqDto=new ObtainPreProgressExecuteCycleStageIdComReqDto();
  if(circulationCollectionsRes!=null){
      obtainPreProgressExecuteCycleStageIdComReqDto.setExecuteCycleStageId(circulationCollectionsRes.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1733057_1_66846
obtainPreProgressExecuteCycleStageIdComReqDto.setTargetCycleContentId(circulationCollectionsRes.getRelateContentId());//SimpleFieldAssign//sourceId:1737457_1_66846
obtainPreProgressExecuteCycleStageIdComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1733059_1_66846
    }

    /*D3获取上一个过程或子周期执行周期阶段ID(公共)[9389]   */
    Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getTargetCycleContentId(),"D3循环更新目标内容执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getEvaluationTemplateId(),"D3循环更新目标内容执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-冗余评价模板ID不能为空",false);
      obtainPreProgressExecuteCycleStageIdComRespDto = obtainPreProgressExecuteCycleStageIdCom(obtainPreProgressExecuteCycleStageIdComReqDto)/*vcase invoke 同服务,同domain*/;



OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1925271_1_71405
queryExecuteCycleStageDetailReq.setIsSubCycle("TRUE");//sourceId:1925272_1_71405
queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1925274_1_71405
if(circulationCollectionsRes!=null){
      queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1925270_1_71405
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1925273_1_71405
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(),"D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(),"D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(),"D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3循环更新目标内容执行周期阶段(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



AddTargetContenteExecutionCycleComRespDto addTargetContenteExecutionCycleComRespDto = null;
    if(obtainPreProgressExecuteCycleStageIdComRespDto !=null&&omsExecuteCycleStage !=null){
          AddTargetContenteExecutionCycleComReqDto addTargetContenteExecutionCycleComReqDto=new AddTargetContenteExecutionCycleComReqDto();
  if(obtainPreProgressExecuteCycleStageIdComRespDto!=null){
      addTargetContenteExecutionCycleComReqDto.setLastExecuteCycleStageId(obtainPreProgressExecuteCycleStageIdComRespDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728248_1_66791
    }
if(omsExecuteCycleStage!=null){
      addTargetContenteExecutionCycleComReqDto.setRelateExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728249_1_66791
    }
if(circulationCollectionsRes!=null){
addTargetContenteExecutionCycleComReqDto.setPeriodId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1727758_1_66791
addTargetContenteExecutionCycleComReqDto.setCycleStandardName(circulationCollectionsRes.getCycleStandardName());//SimpleFieldAssign//sourceId:1728256_1_66791
addTargetContenteExecutionCycleComReqDto.setCycleStartTime(circulationCollectionsRes.getCycleStartTime());//SimpleFieldAssign//sourceId:1727759_1_66791
addTargetContenteExecutionCycleComReqDto.setCycleEndTime(circulationCollectionsRes.getCycleEndTime());//SimpleFieldAssign//sourceId:1727760_1_66791
addTargetContenteExecutionCycleComReqDto.setCycleTypeCode(circulationCollectionsRes.getCycleTypeCode());//SimpleFieldAssign//sourceId:1727761_1_66791
addTargetContenteExecutionCycleComReqDto.setCycleTypeInstanceCode(circulationCollectionsRes.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1727762_1_66791
addTargetContenteExecutionCycleComReqDto.setIsProcessCycleStage(circulationCollectionsRes.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1727766_1_66791
addTargetContenteExecutionCycleComReqDto.setIsDefinedExecuteCycleStage(circulationCollectionsRes.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1727767_1_66791
addTargetContenteExecutionCycleComReqDto.setFillStartTime(circulationCollectionsRes.getFillStartTime());//SimpleFieldAssign//sourceId:1727768_1_66791
addTargetContenteExecutionCycleComReqDto.setFillEndtTime(circulationCollectionsRes.getFillEndtTime());//SimpleFieldAssign//sourceId:1727769_1_66791
addTargetContenteExecutionCycleComReqDto.setEvaluateStartTime(circulationCollectionsRes.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1727770_1_66791
addTargetContenteExecutionCycleComReqDto.setEvaluateEndtTime(circulationCollectionsRes.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1727771_1_66791
addTargetContenteExecutionCycleComReqDto.setIsCurrentCycle(circulationCollectionsRes.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1727773_1_66791
addTargetContenteExecutionCycleComReqDto.setIsNextCycle(circulationCollectionsRes.getIsNextCycle());//SimpleFieldAssign//sourceId:1727774_1_66791
addTargetContenteExecutionCycleComReqDto.setIsStartCycle(circulationCollectionsRes.getIsStartCycle());//SimpleFieldAssign//sourceId:1727775_1_66791
addTargetContenteExecutionCycleComReqDto.setIsEndCycle(circulationCollectionsRes.getIsEndCycle());//SimpleFieldAssign//sourceId:1727776_1_66791
addTargetContenteExecutionCycleComReqDto.setIsLastCycle(circulationCollectionsRes.getIsLastCycle());//SimpleFieldAssign//sourceId:1728206_1_66791
addTargetContenteExecutionCycleComReqDto.setNextCyclePeriod(circulationCollectionsRes.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1728207_1_66791
addTargetContenteExecutionCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1727757_1_66791
addTargetContenteExecutionCycleComReqDto.setIsParentCycle(circulationCollectionsRes.getIsFatherCycle());//SimpleFieldAssign//sourceId:1727763_1_66791
addTargetContenteExecutionCycleComReqDto.setIsMetaphase(circulationCollectionsRes.getIsMetaphase());//SimpleFieldAssign//sourceId:1727764_1_66791
addTargetContenteExecutionCycleComReqDto.setIsSubCycle(circulationCollectionsRes.getIsSubCycle());//SimpleFieldAssign//sourceId:1727765_1_66791
addTargetContenteExecutionCycleComReqDto.setOrderNumber(circulationCollectionsRes.getOrderNumber());//SimpleFieldAssign//sourceId:1728208_1_66791
addTargetContenteExecutionCycleComReqDto.setEvaTempCreateTime(circulationCollectionsRes.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:1728209_1_66791
addTargetContenteExecutionCycleComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getRelateContentTypeCode());//SimpleFieldAssign//sourceId:1727777_1_66791
addTargetContenteExecutionCycleComReqDto.setTargetCycleContentId(circulationCollectionsRes.getRelateContentId());//SimpleFieldAssign//sourceId:1727778_1_66791
addTargetContenteExecutionCycleComReqDto.setTargetId(circulationCollectionsRes.getTargetId());//SimpleFieldAssign//sourceId:1727779_1_66791
addTargetContenteExecutionCycleComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1727780_1_66791
    }

    /*D3新增目标内容执行周期(公共)[9386]   */
    Assert.isNull(addTargetContenteExecutionCycleComReqDto.getPeriodId(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStandardName(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期名称不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleStartTime(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期开始时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleEndTime(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期结束时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getCycleTypeCode(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期类型标识不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsProcessCycleStage(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否过程周期阶段不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsDefinedExecuteCycleStage(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否自定义执行周期阶段不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillStartTime(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报开始时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getFillEndtTime(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-填报结束时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsCurrentCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期当前不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsNextCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级/子周期下一个不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsStartCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否开始子周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsEndCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否截止子周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsLastCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否末级周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaObjTargetCycleId(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsParentCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否父周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsMetaphase(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否中期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getIsSubCycle(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-是否子周期不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getOrderNumber(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-周期排序不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaTempCreateTime(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-评价模板创建时间不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentTypeCode(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetCycleContentId(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getTargetId(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(addTargetContenteExecutionCycleComReqDto.getEvaluationTemplateId(),"D3循环更新目标内容执行周期阶段(公共)-D3新增目标内容执行周期(公共)-冗余评价模板ID不能为空",false);
      addTargetContenteExecutionCycleComRespDto = addTargetContenteExecutionCycleCom(addTargetContenteExecutionCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//ModelCode: circulationEnd
        }

      }
LoopUpdateTargetConExecuteCycleStageComRespDto retData = new LoopUpdateTargetConExecuteCycleStageComRespDto();





return retData;
  }
/**
   * D3获取上一个过程或子周期执行周期阶段ID(公共)[9389]
   * gen by moon at 4/19/2024, 1:00:49 AM
   */
  @Trace(operationName = "D3获取上一个过程或子周期执行周期阶段ID(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainPreProgressExecuteCycleStageIdComRespDto obtainPreProgressExecuteCycleStageIdCom(ObtainPreProgressExecuteCycleStageIdComReqDto reqDto){


      ImplementSevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&& reqDto.getExecuteCycleStageId() != null )) {
        //if(D3获取上一个过程或子周期执行周期阶段ID(公共).执行周期阶段ID 值不等于空 )  66836

      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1733121_1_66838
  if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1728976_1_66838
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1732754_1_66838
    }

    /*3-3-07查询发牌目标的上一个执行周期阶段的周期ID[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询发牌目标的上一个执行周期阶段的周期ID-执行周期阶段ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询发牌目标的上一个执行周期阶段的周期ID-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询发牌目标的上一个执行周期阶段的周期ID-是否存档不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
    if(omsExecuteCycleStage !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:1733125_1_66913
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_1.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1737456_1_66913
queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1733124_1_66913
    }
  if(omsExecuteCycleStage!=null){
      queryExecuteCycleStageDetailReq_1.setCycleId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:1733123_1_66913
    }

    /*3-3-07查询当前内容上一个刚增的执行周期阶段ID[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getRelateContentId(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getCycleId(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-3-3-07查询当前内容上一个刚增的执行周期阶段ID-是否存档不能为空",false);
      omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementSevenReceivingFieldRespDto receptionServiceRes = null;
    if(omsExecuteCycleStage_2 !=null){
          ImplementSevenReceivingFieldReqDto receptionServiceReq=new ImplementSevenReceivingFieldReqDto();
  if(omsExecuteCycleStage_2!=null){
      receptionServiceReq.setExecuteCycleStageId(omsExecuteCycleStage_2.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1729314_1_66845
    }

    /*M3接收执行周期阶段ID[8654]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getExecuteCycleStageId(),"D3获取上一个过程或子周期执行周期阶段ID(公共)-M3接收执行周期阶段ID-执行周期阶段ID不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementSevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
ObtainPreProgressExecuteCycleStageIdComRespDto retData = new ObtainPreProgressExecuteCycleStageIdComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setExecuteCycleStageId(receptionServiceRes_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1729322_1
    }




return retData;
  }
/**
   * D3执行回写目标内容子周期执行周期阶段(公共)[9392]
   * gen by moon at 7/7/2024, 12:05:04 PM
   */
  @Trace(operationName = "D3执行回写目标内容子周期执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetConSubExecuteCycleStageComRespDto implementTargetConSubExecuteCycleStageCom(ImplementTargetConSubExecuteCycleStageComReqDto reqDto){


      QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto_1 =null;
//virtualUsage M3约定错误描述  69045
      //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("implementTargetConSubExecuteCycleStageCom");//CUSTOM_CONVENTION//sourceId:1817320_1_69045
receptionServiceReq.setCustomField2("DATA_OBJECT");//CUSTOM_CONVENTION//sourceId:1817321_1_69045
receptionServiceReq.setCustomField3("SINGLE_OBJECT");//CUSTOM_CONVENTION//sourceId:1817322_1_69045
receptionServiceReq.setCustomField4("对不起，找不到当前目标内容目标子周期数据集~");//CUSTOM_CONVENTION//sourceId:1817323_1_69045
receptionServiceReq.setCustomField5("对不起，找不到目标的目标子周期ID~");//CUSTOM_CONVENTION//sourceId:1817324_1_69045
receptionServiceReq.setCustomField6("对不起，找不到目标的子周期执行周期阶段~");//CUSTOM_CONVENTION//sourceId:1817325_1_69045

    /*M3约定错误描述[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段3不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField4(),"D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段4不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField5(),"D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段5不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField6(),"D3执行回写目标内容子周期执行周期阶段(公共)-M3约定错误描述-自定义字段6不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq);



//virtualUsage D3-3查询被评对象目标周期列表(公共)  66862
      QueryEvaObjTargetCycleListComRespDto queryEvaObjTargetCycleListComRespDto = null;
    QueryEvaObjTargetCycleListComReqDto queryEvaObjTargetCycleListComReqDto=new QueryEvaObjTargetCycleListComReqDto();
queryEvaObjTargetCycleListComReqDto.setIsSubCycle("TRUE");//sourceId:1729839_1_66862
queryEvaObjTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1732386_1_66862
if(reqDto!=null){
      queryEvaObjTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1729831_1_66862
queryEvaObjTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1729833_1_66862
queryEvaObjTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1729836_1_66862
queryEvaObjTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1729847_1_66862
    }

    /*D3-3查询被评对象目标周期列表(公共)[3451]   */
    Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjEntityId(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaObjTypeCode(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getTargetCycleContentId(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsSubCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getEvaluationTemplateId(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListComReqDto.getIsArchive(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3-3查询被评对象目标周期列表(公共)-是否存档不能为空",false);
      queryEvaObjTargetCycleListComRespDto = targetCycleService.queryEvaObjTargetCycleListCom(queryEvaObjTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


      queryEvaObjTargetCycleListComRespDto_1 = queryEvaObjTargetCycleListComRespDto;
if((queryEvaObjTargetCycleListComRespDto!= null&&  queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3-3查询被评对象目标周期列表-子周期.被评对象目标周期列表数据集条数 大于 0)  66863

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList()){

OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1732748_1_66875
  queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1732388_1_66875
if(circulationCollectionsRes!=null){
      queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1730719_1_66875
queryExecuteCycleStageDetailReq.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1730720_1_66875
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730721_1_66875
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsExecuteCycleStage == null )) {
        //if(3-3-07查询当前子周期执行周期阶段ID（出参主键用于修改）.出参 值等于空 )  69034

ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto = null;
    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto=new ImplementDebugBusinessDataRedisComReqDto();
  implementDebugBusinessDataRedisComReqDto.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69048
if(receptionServiceRes!=null){
      implementDebugBusinessDataRedisComReqDto.setDebugScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1816933_1_69048
implementDebugBusinessDataRedisComReqDto.setWrongObjectDescribe(receptionServiceRes.getCustomField6());//SimpleFieldAssign//sourceId:1816934_1_69048
implementDebugBusinessDataRedisComReqDto.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69048
    }
if(reqDto!=null){
      implementDebugBusinessDataRedisComReqDto.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69048
implementDebugBusinessDataRedisComReqDto.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69048
implementDebugBusinessDataRedisComReqDto.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69048
implementDebugBusinessDataRedisComReqDto.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69048
implementDebugBusinessDataRedisComReqDto.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69048
    }
if(circulationCollectionsRes!=null){
      implementDebugBusinessDataRedisComReqDto.setCustomField8(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1817353_1_69048
    }

    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getBusinessDataObject(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getDebugScene(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getWrongObjectDescribe(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空",false);
      implementDebugBusinessDataRedisComRespDto = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();

queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:1732750_1_66879
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1754809_1_66879
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1754808_1_66879
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1732749_1_66879
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1730969_1_66879
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730971_1_66879
    }
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1730970_1_66879
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle!= null&& omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() == null )) {
        //if(3-3-09查目标的被评对象目标周期ID.被评对象目标周期ID 值等于空 )  69035

ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto_1 = null;
    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto_1=new ImplementDebugBusinessDataRedisComReqDto();
  implementDebugBusinessDataRedisComReqDto_1.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69047
if(receptionServiceRes!=null){
      implementDebugBusinessDataRedisComReqDto_1.setDebugScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1816933_1_69047
implementDebugBusinessDataRedisComReqDto_1.setWrongObjectDescribe(receptionServiceRes.getCustomField6());//SimpleFieldAssign//sourceId:1816934_1_69047
implementDebugBusinessDataRedisComReqDto_1.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69047
    }
if(reqDto!=null){
      implementDebugBusinessDataRedisComReqDto_1.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69047
implementDebugBusinessDataRedisComReqDto_1.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69047
implementDebugBusinessDataRedisComReqDto_1.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69047
implementDebugBusinessDataRedisComReqDto_1.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69047
implementDebugBusinessDataRedisComReqDto_1.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69047
    }
if(circulationCollectionsRes!=null){
      implementDebugBusinessDataRedisComReqDto_1.setCustomField8(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1817353_1_69047
    }

    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
    Assert.isNull(implementDebugBusinessDataRedisComReqDto_1.getBusinessDataObject(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto_1.getDebugScene(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto_1.getWrongObjectDescribe(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空",false);
      implementDebugBusinessDataRedisComRespDto_1 = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setIsSubCycle("TRUE");//sourceId:1732752_1_66868
queryExecuteCycleStageDetailReq_1.setIsProcessCycleStage("FALSE");//sourceId:1732751_1_66868
queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:1732753_1_66868
if(omsEvaluationObjectTargetCycle!=null){
      queryExecuteCycleStageDetailReq_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1731252_1_66868
    }
if(circulationCollectionsRes!=null){
      queryExecuteCycleStageDetailReq_1.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1731253_1_66868
    }
if(reqDto!=null){
      queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1731254_1_66868
    }

    /*3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaObjTargetCycleId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getCycleId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsSubCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsProcessCycleStage(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等-是否存档不能为空",false);
      omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
if((omsExecuteCycleStage_2 == null )) {
        //if(3-3-07查询目标的执行周期阶段：4个时间点+周期类型配置标识+最近可循环周期类型等.出参 值等于空 )  69036

ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto_2 = null;
    ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto_2=new ImplementDebugBusinessDataRedisComReqDto();
  implementDebugBusinessDataRedisComReqDto_2.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69046
if(receptionServiceRes!=null){
      implementDebugBusinessDataRedisComReqDto_2.setDebugScene(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1816933_1_69046
implementDebugBusinessDataRedisComReqDto_2.setWrongObjectDescribe(receptionServiceRes.getCustomField5());//SimpleFieldAssign//sourceId:1816934_1_69046
implementDebugBusinessDataRedisComReqDto_2.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69046
    }
if(reqDto!=null){
      implementDebugBusinessDataRedisComReqDto_2.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69046
implementDebugBusinessDataRedisComReqDto_2.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69046
implementDebugBusinessDataRedisComReqDto_2.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69046
implementDebugBusinessDataRedisComReqDto_2.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69046
implementDebugBusinessDataRedisComReqDto_2.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69046
    }
if(circulationCollectionsRes!=null){
      implementDebugBusinessDataRedisComReqDto_2.setCustomField8(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:1817353_1_69046
    }

    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
    Assert.isNull(implementDebugBusinessDataRedisComReqDto_2.getBusinessDataObject(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto_2.getDebugScene(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto_2.getWrongObjectDescribe(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空",false);
      implementDebugBusinessDataRedisComRespDto_2 = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
ObtainPreProgressExecuteCycleStageIdComRespDto obtainPreProgressExecuteCycleStageIdComRespDto = null;
    if(omsExecuteCycleStage_2 !=null&&omsExecuteCycleStage !=null){
          ObtainPreProgressExecuteCycleStageIdComReqDto obtainPreProgressExecuteCycleStageIdComReqDto=new ObtainPreProgressExecuteCycleStageIdComReqDto();
  if(omsExecuteCycleStage_2!=null){
      obtainPreProgressExecuteCycleStageIdComReqDto.setExecuteCycleStageId(omsExecuteCycleStage_2.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:1733061_1_66865
    }
if(omsExecuteCycleStage!=null){
      obtainPreProgressExecuteCycleStageIdComReqDto.setTargetCycleContentId(omsExecuteCycleStage.getRelateContentId());//SimpleFieldAssign//sourceId:1737458_1_66865
    }
if(reqDto!=null){
      obtainPreProgressExecuteCycleStageIdComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1733063_1_66865
    }

    /*D3获取上一个过程或子周期执行周期阶段ID(公共)[9389]   */
    Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getTargetCycleContentId(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainPreProgressExecuteCycleStageIdComReqDto.getEvaluationTemplateId(),"D3执行回写目标内容子周期执行周期阶段(公共)-D3获取上一个过程或子周期执行周期阶段ID(公共)-冗余评价模板ID不能为空",false);
      obtainPreProgressExecuteCycleStageIdComRespDto = obtainPreProgressExecuteCycleStageIdCom(obtainPreProgressExecuteCycleStageIdComReqDto)/*vcase invoke 同服务,同domain*/;



           }
CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsExecuteCycleStage !=null&&omsExecuteCycleStage_2 !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(omsExecuteCycleStage!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:1923347_1_71369
    }
if(omsExecuteCycleStage_2!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(omsExecuteCycleStage_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1923349_1_71369
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(omsExecuteCycleStage !=null&&omsExecuteCycleStage_2 !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(omsExecuteCycleStage!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:1923347_1_71370
    }
if(omsExecuteCycleStage_2!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(omsExecuteCycleStage_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1923349_1_71370
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")&&checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
        //if((D2目标内容的周期开始时间与目标的周期开始时间对比.时间比较结果 等于 当前（等于） and D2目标内容的周期结束时间与目标的周期结束时间对比.时间比较结果 等于 当前（等于）))  71371

boolean bOOLEAN ;
    if(omsExecuteCycleStage !=null&&obtainPreProgressExecuteCycleStageIdComRespDto !=null&&omsExecuteCycleStage_2 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_4=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage!=null){
      omsExecuteCycleStage_4.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730786_1_71372
    }
if(obtainPreProgressExecuteCycleStageIdComRespDto!=null){
      omsExecuteCycleStage_4.setLastExecuteCycleStageId(obtainPreProgressExecuteCycleStageIdComRespDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730787_1_71372
    }
if(omsExecuteCycleStage_2!=null){
      omsExecuteCycleStage_4.setFillStartTime(omsExecuteCycleStage_2.getFillStartTime());//SimpleFieldAssign//sourceId:1923350_1_71372
omsExecuteCycleStage_4.setFillEndtTime(omsExecuteCycleStage_2.getFillEndtTime());//SimpleFieldAssign//sourceId:1923351_1_71372
omsExecuteCycleStage_4.setEvaluateStartTime(omsExecuteCycleStage_2.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1923352_1_71372
omsExecuteCycleStage_4.setEvaluateEndtTime(omsExecuteCycleStage_2.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1923353_1_71372
omsExecuteCycleStage_4.setIsCurrentCycle(omsExecuteCycleStage_2.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1730793_1_71372
omsExecuteCycleStage_4.setIsNextCycle(omsExecuteCycleStage_2.getIsNextCycle());//SimpleFieldAssign//sourceId:1730795_1_71372
omsExecuteCycleStage_4.setIsStartCycle(omsExecuteCycleStage_2.getIsStartCycle());//SimpleFieldAssign//sourceId:1730794_1_71372
omsExecuteCycleStage_4.setIsEndCycle(omsExecuteCycleStage_2.getIsEndCycle());//SimpleFieldAssign//sourceId:1730796_1_71372
omsExecuteCycleStage_4.setIsLastCycle(omsExecuteCycleStage_2.getIsLastCycle());//SimpleFieldAssign//sourceId:1730797_1_71372
omsExecuteCycleStage_4.setNextCyclePeriod(omsExecuteCycleStage_2.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1730798_1_71372
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_4.getExecuteCycleStageId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsCurrentCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期当前不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsNextCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期下一个不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsStartCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否开始子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsEndCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否截止子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getIsLastCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级周期不能为空",false);
      bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((!(checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))||!(checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))){
       //elseif((D2目标内容的周期开始时间与目标的周期开始时间对比.时间比较结果 不等于 当前（等于） or D2目标内容的周期结束时间与目标的周期结束时间对比.时间比较结果 不等于 当前（等于）))  71373

boolean bOOLEAN_1 ;
    if(omsExecuteCycleStage !=null&&obtainPreProgressExecuteCycleStageIdComRespDto !=null&&omsExecuteCycleStage_2 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_5=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage!=null){
      omsExecuteCycleStage_5.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730786_1_71374
    }
if(obtainPreProgressExecuteCycleStageIdComRespDto!=null){
      omsExecuteCycleStage_5.setLastExecuteCycleStageId(obtainPreProgressExecuteCycleStageIdComRespDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1730787_1_71374
    }
if(omsExecuteCycleStage_2!=null){
      omsExecuteCycleStage_5.setIsCurrentCycle(omsExecuteCycleStage_2.getIsCurrentCycle());//SimpleFieldAssign//sourceId:1730793_1_71374
omsExecuteCycleStage_5.setIsNextCycle(omsExecuteCycleStage_2.getIsNextCycle());//SimpleFieldAssign//sourceId:1730795_1_71374
omsExecuteCycleStage_5.setIsStartCycle(omsExecuteCycleStage_2.getIsStartCycle());//SimpleFieldAssign//sourceId:1730794_1_71374
omsExecuteCycleStage_5.setIsEndCycle(omsExecuteCycleStage_2.getIsEndCycle());//SimpleFieldAssign//sourceId:1730796_1_71374
omsExecuteCycleStage_5.setIsLastCycle(omsExecuteCycleStage_2.getIsLastCycle());//SimpleFieldAssign//sourceId:1730797_1_71374
omsExecuteCycleStage_5.setNextCyclePeriod(omsExecuteCycleStage_2.getNextCyclePeriod());//SimpleFieldAssign//sourceId:1730798_1_71374
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_5.getExecuteCycleStageId(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsCurrentCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期当前不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsNextCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级/子周期下一个不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsStartCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否开始子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsEndCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否截止子周期不能为空",false);
Assert.isNull(omsExecuteCycleStage_5.getIsLastCycle(),"D3执行回写目标内容子周期执行周期阶段(公共)-3-3-07修改执行周期阶段-是否末级周期不能为空",false);
      bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_5)/*vcase invoke 本地 method 方法调用;*/;



           }
           }
//ModelCode: circulationEnd
        }

      }
else if((queryEvaObjTargetCycleListComRespDto!= null&&  queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().size()==0)){
       //elseif(D3-3查询被评对象目标周期列表-子周期.被评对象目标周期列表数据集条数 等于 0)  69033

ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto_3 = null;
    if(queryEvaObjTargetCycleListComRespDto !=null){
          ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto_3=new ImplementDebugBusinessDataRedisComReqDto();
  implementDebugBusinessDataRedisComReqDto_3.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1816920_1_69044
if(receptionServiceRes!=null){
      implementDebugBusinessDataRedisComReqDto_3.setDebugScene(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1816933_1_69044
implementDebugBusinessDataRedisComReqDto_3.setWrongObjectDescribe(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1816934_1_69044
implementDebugBusinessDataRedisComReqDto_3.setCustomField2(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1817347_1_69044
    }
    if(reqDto!=null){
      implementDebugBusinessDataRedisComReqDto_3.setCustomField3(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817348_1_69044
implementDebugBusinessDataRedisComReqDto_3.setCustomField4(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817349_1_69044
implementDebugBusinessDataRedisComReqDto_3.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817350_1_69044
implementDebugBusinessDataRedisComReqDto_3.setCustomField7(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1817352_1_69044
implementDebugBusinessDataRedisComReqDto_3.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817351_1_69044
    }
if(queryEvaObjTargetCycleListComRespDto!= null&&  queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      implementDebugBusinessDataRedisComReqDto_3.setBusinessDataSetList(queryEvaObjTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1816932_1_69044
    }

    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
    Assert.isNull(implementDebugBusinessDataRedisComReqDto_3.getBusinessDataObject(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto_3.getDebugScene(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto_3.getWrongObjectDescribe(),"D3执行回写目标内容子周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空",false);
      implementDebugBusinessDataRedisComRespDto_3 = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



           }
}
ImplementTargetConSubExecuteCycleStageComRespDto retData = new ImplementTargetConSubExecuteCycleStageComRespDto();
  if(queryEvaObjTargetCycleListComRespDto_1!=null){
      retData.setEvaObjTargetCycleList(queryEvaObjTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1731351_1
    }




return retData;
  }
/**
   * D3更新目标内容父中周期执行周期阶段(公共)[9393]
   * gen by moon at 5/27/2024, 10:31:20 PM
   */
  @Trace(operationName = "D3更新目标内容父中周期执行周期阶段(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshTargetConParentAndMidExecuteCycleStageComRespDto refreshTargetConParentAndMidExecuteCycleStageCom(RefreshTargetConParentAndMidExecuteCycleStageComReqDto reqDto){


      OmsExecuteCycleStage omsExecuteCycleStage_1 =null;
QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_1 =null;
      //virtualUsage 3-3-07查询中期/父周期执行周期阶段详情  66872
      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1732758_1_66872
  if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setRelateContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1730665_1_66872
queryExecuteCycleStageDetailReq.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1731326_1_66872
queryExecuteCycleStageDetailReq.setIsFatherCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1731326_1_66872
queryExecuteCycleStageDetailReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1730666_1_66872
queryExecuteCycleStageDetailReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1732589_1_66872
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730667_1_66872
    }

    /*3-3-07查询中期/父周期执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-关联目标内容ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询中期/父周期执行周期阶段详情-评价模板ID不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsExecuteCycleStage_1 = omsExecuteCycleStage;
//virtualUsage D3查询父或中目标周期详请(公共)  67090
      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    if(omsExecuteCycleStage !=null){
          QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1737528_1_67090
if(omsExecuteCycleStage!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(omsExecuteCycleStage.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1737527_1_67090
    }
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737529_1_67090
    }

    /*D3查询父或中目标周期详请(公共)[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中目标周期详请(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中目标周期详请(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中目标周期详请(公共)-是否存档不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;


      queryEvaObjTargetCyclePlatformDetailComRespDto_1 = queryEvaObjTargetCyclePlatformDetailComRespDto;
           }
if((omsExecuteCycleStage != null )) {
        //if(3-3-07查询中期/父周期执行周期阶段详情.出参 值不等于空 )  66877

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto_1=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsSubCycle("TRUE");//sourceId:1737602_1_67091
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1737603_1_67091
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1737598_1_67091
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1737599_1_67091
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1737601_1_67091
    }
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1737600_1_67091
queryEvaObjTargetCyclePlatformDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1737604_1_67091
    }

    /*D3查询父或中结束时间匹配的目标子周期[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjEntityId(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaObjTypeCode(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getTargetCycleContentId(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getCycleEndTime(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-目标计划结束时间不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsSubCycle(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getIsArchive(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-是否存档不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto_1.getEvaluationTemplateId(),"D3更新目标内容父中周期执行周期阶段(公共)-D3查询父或中结束时间匹配的目标子周期-冗余评价模板ID不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto_2 = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto_1)/*vcase invoke isSameApp*/;



           }
OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto_2 !=null){
          QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq_1.setIsSubCycle("TRUE");//sourceId:1730967_1_66878
queryExecuteCycleStageDetailReq_1.setIsProcessCycleStage("FALSE");//sourceId:1732760_1_66878
queryExecuteCycleStageDetailReq_1.setIsArchive("FALSE");//sourceId:1732759_1_66878
if(queryEvaObjTargetCyclePlatformDetailComRespDto_2!=null){
      queryExecuteCycleStageDetailReq_1.setEvaObjTargetCycleId(queryEvaObjTargetCyclePlatformDetailComRespDto_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1737608_1_66878
    }
if(reqDto!=null){
queryExecuteCycleStageDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1730968_1_66878
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaObjTargetCycleId(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsSubCycle(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsProcessCycleStage(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getIsArchive(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq_1.getEvaluationTemplateId(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
      omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsExecuteCycleStage_2== null||  omsExecuteCycleStage_2.getExecuteCycleStageId() ==null,"找不到数据，系统异常",false);


           }
if((omsExecuteCycleStage_2 == null )) {
        //if(3-3-07查与中期/父周期结束时间相同的子周期执行周期详情.出参 值等于空 )  69049

ImplementDebugBusinessDataRedisComRespDto implementDebugBusinessDataRedisComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementDebugBusinessDataRedisComReqDto implementDebugBusinessDataRedisComReqDto=new ImplementDebugBusinessDataRedisComReqDto();
  implementDebugBusinessDataRedisComReqDto.setBusinessDataObject("BUSINESS_DATA_OBJECT_TEST");//sourceId:1817332_1_69050
implementDebugBusinessDataRedisComReqDto.setDebugScene("SINGLE_OBJECT");//CUSTOM_CONVENTION//sourceId:1817345_1_69050
implementDebugBusinessDataRedisComReqDto.setWrongObjectDescribe("对不起，找不到当前目标内容父或中自定义执行周期阶段~");//CUSTOM_CONVENTION//sourceId:1817346_1_69050
implementDebugBusinessDataRedisComReqDto.setCustomField2("refreshTargetConParentAndMidExecuteCycleStageCom");//CUSTOM_CONVENTION//sourceId:1817354_1_69050
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      implementDebugBusinessDataRedisComReqDto.setCustomField3(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1817355_1_69050
implementDebugBusinessDataRedisComReqDto.setCustomField4(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1817356_1_69050
    }
if(reqDto!=null){
      implementDebugBusinessDataRedisComReqDto.setCustomField5(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1817357_1_69050
implementDebugBusinessDataRedisComReqDto.setCustomField6(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1817358_1_69050
    }

    /*D2执行DEBUG业务对象数据Redis(公共)[9660]   */
    Assert.isNull(implementDebugBusinessDataRedisComReqDto.getBusinessDataObject(),"D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-业务数据对象不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getDebugScene(),"D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-DEBUG业务场景不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getWrongObjectDescribe(),"D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-错误对象描述不能为空",false);
Assert.isNull(implementDebugBusinessDataRedisComReqDto.getCustomField2(),"D3更新目标内容父中周期执行周期阶段(公共)-D2执行DEBUG业务对象数据Redis(公共)-接口地址不能为空",false);
      implementDebugBusinessDataRedisComRespDto = fwCompBusinessAtomClient.implementDebugBusinessDataRedisCom(implementDebugBusinessDataRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
           }
boolean bOOLEAN ;
    if(omsExecuteCycleStage !=null&&omsExecuteCycleStage_2 !=null){
          OmsExecuteCycleStage omsExecuteCycleStage_4=new OmsExecuteCycleStage();
  if(omsExecuteCycleStage!=null){
      omsExecuteCycleStage_4.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1731256_1_66880
    }
if(omsExecuteCycleStage_2!=null){
      omsExecuteCycleStage_4.setFillStartTime(omsExecuteCycleStage_2.getFillStartTime());//SimpleFieldAssign//sourceId:1731257_1_66880
omsExecuteCycleStage_4.setFillEndtTime(omsExecuteCycleStage_2.getFillEndtTime());//SimpleFieldAssign//sourceId:1731258_1_66880
omsExecuteCycleStage_4.setEvaluateStartTime(omsExecuteCycleStage_2.getEvaluateStartTime());//SimpleFieldAssign//sourceId:1731259_1_66880
omsExecuteCycleStage_4.setEvaluateEndtTime(omsExecuteCycleStage_2.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:1731260_1_66880
    }
if(reqDto!=null){
      omsExecuteCycleStage_4.setNextCyclePeriod(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1731261_1_66880
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage_4.getExecuteCycleStageId(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getFillStartTime(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-填报开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getFillEndtTime(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-填报结束时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getEvaluateStartTime(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-评价开始时间不能为空",false);
Assert.isNull(omsExecuteCycleStage_4.getEvaluateEndtTime(),"D3更新目标内容父中周期执行周期阶段(公共)-3-3-07修改执行周期阶段-评价结束时间不能为空",false);
      bOOLEAN = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
RefreshTargetConParentAndMidExecuteCycleStageComRespDto retData = new RefreshTargetConParentAndMidExecuteCycleStageComRespDto();
  if(omsExecuteCycleStage_1!=null){
      retData.setExecuteCycleStageId(omsExecuteCycleStage_1.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1732761_1
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto_1!=null){
      retData.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1737610_1
retData.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1737611_1
    }




return retData;
  }
/**
   * D3执行回删自定义执行周期(公共)[9449]
   * gen by moon at 4/28/2024, 2:33:55 PM
   */
  @Trace(operationName = "D3执行回删自定义执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOverwriteDelCustomExeCycleComRespDto implementOverwriteDelCustomExeCycleCom(ImplementOverwriteDelCustomExeCycleComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getEvaObjTargetCycleList() !=null && reqDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3执行回删自定义执行周期(公共).被评对象目标周期列表数据集条数 大于 0)  67505

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: reqDto.getEvaObjTargetCycleList()){

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1755366_1_67508
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755365_1_67508
    }
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755367_1_67508
    }

    /*D3查当前子周期牌目标计划开始时间与结束时间[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3执行回删自定义执行周期(公共)-D3查当前子周期牌目标计划开始时间与结束时间-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3执行回删自定义执行周期(公共)-D3查当前子周期牌目标计划开始时间与结束时间-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3执行回删自定义执行周期(公共)-D3查当前子周期牌目标计划开始时间与结束时间-是否存档不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(circulationCollectionsRes!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1755353_1_67509
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1755355_1_67509
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(circulationCollectionsRes!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1755353_1_67510
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1755355_1_67510
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3执行回删自定义执行周期(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((!(checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")))) {
        //if(D2子周期成果汇报开始时间与目标计划开始时间对比（A）.时间比较结果 不等于 当前（等于）)  67511

boolean bOOLEAN ;
    OmsTargetCyclePlanSet omsTargetCyclePlanSet=new OmsTargetCyclePlanSet();
  if(circulationCollectionsRes!=null){
      omsTargetCyclePlanSet.setTargetCyclePlanSetId(circulationCollectionsRes.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:1756857_1_67573
omsTargetCyclePlanSet.setTargetActualStartTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1756860_1_67573
    }

    /*3-3-08修改目标周期规划设置[6293]   */
    Assert.isNull(omsTargetCyclePlanSet.getTargetCyclePlanSetId(),"D3执行回删自定义执行周期(公共)-3-3-08修改目标周期规划设置-目标周期规划设置ID不能为空",false);
      bOOLEAN = mOmsTargetCyclePlanSetService.updateTargetCyclePset(omsTargetCyclePlanSet)/*vcase invoke 本地 method 方法调用;*/;



List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryExecuteCycleGreaterAndEqualStartListReq queryExecuteCycleGreaterAndEqualStartListReq=new QueryExecuteCycleGreaterAndEqualStartListReq();
  queryExecuteCycleGreaterAndEqualStartListReq.setIsProcessCycleStage("TRUE");//sourceId:1755386_1_67512
queryExecuteCycleGreaterAndEqualStartListReq.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1755387_1_67512
queryExecuteCycleGreaterAndEqualStartListReq.setIsArchive("FALSE");//sourceId:1755388_1_67512
if(circulationCollectionsRes!=null){
      queryExecuteCycleGreaterAndEqualStartListReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755391_1_67512
queryExecuteCycleGreaterAndEqualStartListReq.setCycleEndTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1755393_1_67512
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryExecuteCycleGreaterAndEqualStartListReq.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1755392_1_67512
    }
if(reqDto!=null){
      queryExecuteCycleGreaterAndEqualStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755389_1_67512
    }

    /*3-3-07-查询执行周期列表（开始大于等于&结束小于）[6660]   */
    Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getEvaObjTargetCycleId(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getCycleStartTime(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getCycleEndTime(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getEvaluationTemplateId(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsProcessCycleStage(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsDefinedExecuteCycleStage(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否自定义执行周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleGreaterAndEqualStartListReq.getIsArchive(),"D3执行回删自定义执行周期(公共)-3-3-07-查询执行周期列表（开始大于等于&结束小于）-是否存档不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleGreaterAndEqualStartList(queryExecuteCycleGreaterAndEqualStartListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_1 ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listString = listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1755385_1_67513
    }

    /*3-3-07批量删执行周期阶段[2743]   */

      bOOLEAN_1 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          BatchQueryTimerTaskPlanReq batchQueryTimerTaskPlanReq=new BatchQueryTimerTaskPlanReq();
  batchQueryTimerTaskPlanReq.setDispatchActionTypeCode("DISPATCH_ADD_REPORT_TASK");//sourceId:1755949_1_67532
batchQueryTimerTaskPlanReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1755950_1_67532
if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      batchQueryTimerTaskPlanReq.setTimerTaskPlanList(listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1755948_1_67532
    }
if(reqDto!=null){
      batchQueryTimerTaskPlanReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755960_1_67532
    }

    /*3-2-09批量查询定时任务调度[3531]   */
    Assert.isNull(batchQueryTimerTaskPlanReq.getDispatchActionTypeCode(),"D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度的行为类型编码不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq.getTaskDispatchTypeCode(),"D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度类型编码不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq.getThemeContentId(),"D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-主题内容ID不能为空",false);
      listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.batchQueryTimerTaskPlan(batchQueryTimerTaskPlanReq)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_2 ;
    if(listOmsTargetTimingTaskDispatch !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)&& listOmsTargetTimingTaskDispatch.size()>0 ){
          List<String> listString_1=new ArrayList<>();
  if(listOmsTargetTimingTaskDispatch!= null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)&&  listOmsTargetTimingTaskDispatch !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)){
      listString_1 = listOmsTargetTimingTaskDispatch.stream().map(item->item.getTimingTaskDispatchId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1755958_1_67533
    }

    /*3-2-09批量删定时任务调度[3277]   */

      bOOLEAN_2 = mOmsTargetTimingTaskDispatchService.batchDeleteTimerTaskPlan(listString_1)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
if((!(checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
        //if(D2子周期成果汇报结束时间与目标计划结束时间对比（B）.时间比较结果 不等于 当前（等于）)  67515

boolean bOOLEAN_3 ;
    OmsTargetCyclePlanSet omsTargetCyclePlanSet_1=new OmsTargetCyclePlanSet();
  if(circulationCollectionsRes!=null){
      omsTargetCyclePlanSet_1.setTargetCyclePlanSetId(circulationCollectionsRes.getTargetCyclePlanSetId());//SimpleFieldAssign//sourceId:1756857_1_67574
omsTargetCyclePlanSet_1.setTargetActualEndtTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1756861_1_67574
omsTargetCyclePlanSet_1.setAcceptancePlanTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1756862_1_67574
    }

    /*3-3-08修改目标周期规划设置[6293]   */
    Assert.isNull(omsTargetCyclePlanSet_1.getTargetCyclePlanSetId(),"D3执行回删自定义执行周期(公共)-3-3-08修改目标周期规划设置-目标周期规划设置ID不能为空",false);
      bOOLEAN_3 = mOmsTargetCyclePlanSetService.updateTargetCyclePset(omsTargetCyclePlanSet_1)/*vcase invoke 本地 method 方法调用;*/;



List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 =new ArrayList<>();
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryTimeMatchExecCycleList2Req queryTimeMatchExecCycleList2Req=new QueryTimeMatchExecCycleList2Req();
  queryTimeMatchExecCycleList2Req.setIsProcessCycleStage("TRUE");//sourceId:1755398_1_67517
queryTimeMatchExecCycleList2Req.setIsDefinedExecuteCycleStage("TRUE");//sourceId:1755406_1_67517
if(circulationCollectionsRes!=null){
      queryTimeMatchExecCycleList2Req.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755409_1_67517
queryTimeMatchExecCycleList2Req.setCycleStartTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1755395_1_67517
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryTimeMatchExecCycleList2Req.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1755396_1_67517
    }
if(reqDto!=null){
      queryTimeMatchExecCycleList2Req.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755402_1_67517
    }

    /*3-3-07时间匹配执行周期列表（开始大于&结束小于等于）[6321]   */
    Assert.isNull(queryTimeMatchExecCycleList2Req.getEvaObjTargetCycleId(),"D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryTimeMatchExecCycleList2Req.getCycleStartTime(),"D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-周期开始时间不能为空",false);
Assert.isNull(queryTimeMatchExecCycleList2Req.getCycleEndTime(),"D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-周期结束时间不能为空",false);
Assert.isNull(queryTimeMatchExecCycleList2Req.getEvaluationTemplateId(),"D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-评价模板ID不能为空",false);
Assert.isNull(queryTimeMatchExecCycleList2Req.getIsProcessCycleStage(),"D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryTimeMatchExecCycleList2Req.getIsDefinedExecuteCycleStage(),"D3执行回删自定义执行周期(公共)-3-3-07时间匹配执行周期列表（开始大于&结束小于等于）-是否自定义执行周期阶段不能为空",false);
      listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryTimeMatchExecCycleList2(queryTimeMatchExecCycleList2Req)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_4 ;
    if(listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&& listOmsExecuteCycleStage_2.size()>0 ){
          List<String> listString_2=new ArrayList<>();
  if(listOmsExecuteCycleStage_2!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&&  listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)){
      listString_2 = listOmsExecuteCycleStage_2.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1755385_1_67516
    }

    /*3-3-07批量删执行周期阶段[2743]   */

      bOOLEAN_4 = mOmsExecuteCycleStageService.batchDeleteExecuteCycleStage(listString_2)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch_2 =new ArrayList<>();
    if(listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&& listOmsExecuteCycleStage_2.size()>0 ){
          BatchQueryTimerTaskPlanReq batchQueryTimerTaskPlanReq_1=new BatchQueryTimerTaskPlanReq();
  batchQueryTimerTaskPlanReq_1.setDispatchActionTypeCode("DISPATCH_ADD_REPORT_TASK");//sourceId:1755949_1_67534
batchQueryTimerTaskPlanReq_1.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1755950_1_67534
if(listOmsExecuteCycleStage_2!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&&  listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)){
      batchQueryTimerTaskPlanReq_1.setTimerTaskPlanList(listOmsExecuteCycleStage_2.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1755948_1_67534
    }
if(reqDto!=null){
      batchQueryTimerTaskPlanReq_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755960_1_67534
    }

    /*3-2-09批量查询定时任务调度[3531]   */
    Assert.isNull(batchQueryTimerTaskPlanReq_1.getDispatchActionTypeCode(),"D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度的行为类型编码不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq_1.getTaskDispatchTypeCode(),"D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-任务调度类型编码不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq_1.getThemeContentId(),"D3执行回删自定义执行周期(公共)-3-2-09批量查询定时任务调度-主题内容ID不能为空",false);
      listOmsTargetTimingTaskDispatch_2 = mOmsTargetTimingTaskDispatchService.batchQueryTimerTaskPlan(batchQueryTimerTaskPlanReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_5 ;
    if(listOmsTargetTimingTaskDispatch_2 !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch_2)&& listOmsTargetTimingTaskDispatch_2.size()>0 ){
          List<String> listString_3=new ArrayList<>();
  if(listOmsTargetTimingTaskDispatch_2!= null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch_2)&&  listOmsTargetTimingTaskDispatch_2 !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch_2)){
      listString_3 = listOmsTargetTimingTaskDispatch_2.stream().map(item->item.getTimingTaskDispatchId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1755958_1_67535
    }

    /*3-2-09批量删定时任务调度[3277]   */

      bOOLEAN_5 = mOmsTargetTimingTaskDispatchService.batchDeleteTimerTaskPlan(listString_3)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
//ModelCode: circulationEnd
        }

      }
ImplementOverwriteDelCustomExeCycleComRespDto retData = new ImplementOverwriteDelCustomExeCycleComRespDto();





return retData;
  }
/**
   * D3回写目标内容父或中成果汇报时间(公共)[9450]
   * gen by moon at 4/27/2024, 2:18:11 AM
   */
  @Trace(operationName = "D3回写目标内容父或中成果汇报时间(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto implementOverwriteTargetContFatherOrMidReportTimeCom(ImplementOverwriteTargetContFatherOrMidReportTimeComReqDto reqDto){


      //virtualUsage D3查询目标内容父或中目标周期详请  67525
      QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1755851_1_67525
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755924_1_67525
queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755852_1_67525
    }

    /*D3查询目标内容父或中目标周期详请[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标内容父或中目标周期详请-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标内容父或中目标周期详请-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标内容父或中目标周期详请-是否存档不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3查询目标子周期规划设置详情(公共)  67527
      QueryTargetSubCyclePlanSetDetailComRespDto queryTargetSubCyclePlanSetDetailComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryTargetSubCyclePlanSetDetailComReqDto queryTargetSubCyclePlanSetDetailComReqDto=new QueryTargetSubCyclePlanSetDetailComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryTargetSubCyclePlanSetDetailComReqDto.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1755770_1_67527
queryTargetSubCyclePlanSetDetailComReqDto.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1755771_1_67527
queryTargetSubCyclePlanSetDetailComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1755772_1_67527
queryTargetSubCyclePlanSetDetailComReqDto.setCycleStartTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1755773_1_67527
    }
if(reqDto!=null){
      queryTargetSubCyclePlanSetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755775_1_67527
    }

    /*D3查询目标子周期规划设置详情(公共)[6875]   */
    Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getEvaObjEntityId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getEvaObjTypeCode(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getTargetCycleContentId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto.getEvaluationTemplateId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetSubCyclePlanSetDetailComRespDto = targetCycleService.queryTargetSubCyclePlanSetDetailCom(queryTargetSubCyclePlanSetDetailComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3修改目标实际起止时间(公共)  67529
      UpdateTargetActualStartEndtTimeComRespDto updateTargetActualStartEndtTimeComRespDto = null;
    if(queryTargetSubCyclePlanSetDetailComRespDto !=null){
          UpdateTargetActualStartEndtTimeComReqDto updateTargetActualStartEndtTimeComReqDto=new UpdateTargetActualStartEndtTimeComReqDto();
  if(reqDto!=null){
      updateTargetActualStartEndtTimeComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755942_1_67529
updateTargetActualStartEndtTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755945_1_67529
    }
if(queryTargetSubCyclePlanSetDetailComRespDto!=null){
      updateTargetActualStartEndtTimeComReqDto.setTargetActualStartTime(queryTargetSubCyclePlanSetDetailComRespDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1755943_1_67529
    }

    /*D3修改目标实际起止时间(公共)[6872]   */
    Assert.isNull(updateTargetActualStartEndtTimeComReqDto.getEvaObjTargetCycleId(),"D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(updateTargetActualStartEndtTimeComReqDto.getEvaluationTemplateId(),"D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-冗余评价模板ID不能为空",false);
      updateTargetActualStartEndtTimeComRespDto = targetCycleService.updateTargetActualStartEndtTimeCom(updateTargetActualStartEndtTimeComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3查询目标子周期规划设置详情(公共)  67530
      QueryTargetSubCyclePlanSetDetailComRespDto queryTargetSubCyclePlanSetDetailComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          QueryTargetSubCyclePlanSetDetailComReqDto queryTargetSubCyclePlanSetDetailComReqDto_1=new QueryTargetSubCyclePlanSetDetailComReqDto();
  if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      queryTargetSubCyclePlanSetDetailComReqDto_1.setEvaObjEntityId(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1755770_1_67530
queryTargetSubCyclePlanSetDetailComReqDto_1.setEvaObjTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1755771_1_67530
queryTargetSubCyclePlanSetDetailComReqDto_1.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1755772_1_67530
queryTargetSubCyclePlanSetDetailComReqDto_1.setCycleEndTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1755774_1_67530
    }
if(reqDto!=null){
      queryTargetSubCyclePlanSetDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755775_1_67530
    }

    /*D3查询目标子周期规划设置详情(公共)[6875]   */
    Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getEvaObjEntityId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getEvaObjTypeCode(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getTargetCycleContentId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetSubCyclePlanSetDetailComReqDto_1.getEvaluationTemplateId(),"D3回写目标内容父或中成果汇报时间(公共)-D3查询目标子周期规划设置详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetSubCyclePlanSetDetailComRespDto_2 = targetCycleService.queryTargetSubCyclePlanSetDetailCom(queryTargetSubCyclePlanSetDetailComReqDto_1)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3修改目标实际起止时间(公共)  67531
      UpdateTargetActualStartEndtTimeComRespDto updateTargetActualStartEndtTimeComRespDto_1 = null;
    if(queryTargetSubCyclePlanSetDetailComRespDto_2 !=null){
          UpdateTargetActualStartEndtTimeComReqDto updateTargetActualStartEndtTimeComReqDto_1=new UpdateTargetActualStartEndtTimeComReqDto();
  if(reqDto!=null){
      updateTargetActualStartEndtTimeComReqDto_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1755942_1_67531
updateTargetActualStartEndtTimeComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1755945_1_67531
    }
if(queryTargetSubCyclePlanSetDetailComRespDto_2!=null){
      updateTargetActualStartEndtTimeComReqDto_1.setTargetActualEndtTime(queryTargetSubCyclePlanSetDetailComRespDto_2.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1755944_1_67531
    }

    /*D3修改目标实际起止时间(公共)[6872]   */
    Assert.isNull(updateTargetActualStartEndtTimeComReqDto_1.getEvaObjTargetCycleId(),"D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(updateTargetActualStartEndtTimeComReqDto_1.getEvaluationTemplateId(),"D3回写目标内容父或中成果汇报时间(公共)-D3修改目标实际起止时间(公共)-冗余评价模板ID不能为空",false);
      updateTargetActualStartEndtTimeComRespDto_1 = targetCycleService.updateTargetActualStartEndtTimeCom(updateTargetActualStartEndtTimeComReqDto_1)/*vcase invoke isSameApp*/;



           }
ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto retData = new ImplementOverwriteTargetContFatherOrMidReportTimeComRespDto();





return retData;
  }
/**
   * D3回删目标内容汇报任务任务调度(公共)[9451]
   * gen by moon at 4/27/2024, 2:18:35 AM
   */
  @Trace(operationName = "D3回删目标内容汇报任务任务调度(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto implementOverwriteDelTargetContReportTimerTaskPlanCom(ImplementOverwriteDelTargetContReportTimerTaskPlanComReqDto reqDto){


      //virtualUsage D3查询被评目标周期列表(公共)  67536
      QueryEvaTargetCycleListComRespDto queryEvaTargetCycleListComRespDto = null;
    QueryEvaTargetCycleListComReqDto queryEvaTargetCycleListComReqDto=new QueryEvaTargetCycleListComReqDto();
  queryEvaTargetCycleListComReqDto.setIsArchive("FALSE");//sourceId:1756235_1_67536
if(reqDto!=null){
      queryEvaTargetCycleListComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1756226_1_67536
queryEvaTargetCycleListComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1756227_1_67536
queryEvaTargetCycleListComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756229_1_67536
queryEvaTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756234_1_67536
    }

    /*D3查询被评目标周期列表(公共)[9416]   */
    Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjEntityId(),"D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaObjTypeCode(),"D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getTargetCycleContentId(),"D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getEvaluationTemplateId(),"D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaTargetCycleListComReqDto.getIsArchive(),"D3回删目标内容汇报任务任务调度(公共)-D3查询被评目标周期列表(公共)-是否存档不能为空",false);
      queryEvaTargetCycleListComRespDto = targetContComService.queryEvaTargetCycleListCom(queryEvaTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



if((queryEvaTargetCycleListComRespDto!= null&&  queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null && queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3查询当前目标内容目标周期列表(公共).被评对象目标周期列表数据集条数 大于 0)  67538

List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleStageListReq queryExecuteCycleStageListReq=new QueryExecuteCycleStageListReq();
  queryExecuteCycleStageListReq.setRelateContentTypeCode("TARGET");//sourceId:1756325_1_67539
queryExecuteCycleStageListReq.setIsArchive("FALSE");//sourceId:1756267_1_67539
if(reqDto!=null){
      queryExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756266_1_67539
    }

    /*3-3-07查目标执行周期阶段列表[3201]   */
    Assert.isNull(queryExecuteCycleStageListReq.getEvaluationTemplateId(),"D3回删目标内容汇报任务任务调度(公共)-3-3-07查目标执行周期阶段列表-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getRelateContentTypeCode(),"D3回删目标内容汇报任务任务调度(公共)-3-3-07查目标执行周期阶段列表-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsArchive(),"D3回删目标内容汇报任务任务调度(公共)-3-3-07查目标执行周期阶段列表-是否存档不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryEvaTargetCycleListComRespDto.getEvaObjTargetCycleList()){

List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch =new ArrayList<>();
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          BatchQueryTimerTaskPlanReq batchQueryTimerTaskPlanReq=new BatchQueryTimerTaskPlanReq();
  batchQueryTimerTaskPlanReq.setDispatchActionTypeCode("DISPATCH_ADD_REPORT_TASK");//sourceId:1756314_1_67542
batchQueryTimerTaskPlanReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1756315_1_67542
if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      batchQueryTimerTaskPlanReq.setTimerTaskPlanList(listOmsExecuteCycleStage.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1756313_1_67542
    }
if(circulationCollectionsRes!=null){
      batchQueryTimerTaskPlanReq.setObjectId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1756317_1_67542
    }
if(reqDto!=null){
      batchQueryTimerTaskPlanReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756323_1_67542
    }

    /*3-2-09批量查询定时任务调度[3531]   */
    Assert.isNull(batchQueryTimerTaskPlanReq.getDispatchActionTypeCode(),"D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-任务调度的行为类型编码不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq.getTaskDispatchTypeCode(),"D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-任务调度类型编码不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq.getObjectId(),"D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-归属对象内容ID不能为空",false);
Assert.isNull(batchQueryTimerTaskPlanReq.getThemeContentId(),"D3回删目标内容汇报任务任务调度(公共)-3-2-09批量查询定时任务调度-主题内容ID不能为空",false);
      listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.batchQueryTimerTaskPlan(batchQueryTimerTaskPlanReq)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN ;
    if(listOmsTargetTimingTaskDispatch !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)&& listOmsTargetTimingTaskDispatch.size()>0 ){
          List<String> listString=new ArrayList<>();
  if(listOmsTargetTimingTaskDispatch!= null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)&&  listOmsTargetTimingTaskDispatch !=null&& !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)){
      listString = listOmsTargetTimingTaskDispatch.stream().map(item->item.getTimingTaskDispatchId())
        .collect(Collectors.toList());/*list-to-strings*///sourceId:1756324_1_67543
    }

    /*3-2-09批量删定时任务调度[3277]   */

      bOOLEAN = mOmsTargetTimingTaskDispatchService.batchDeleteTimerTaskPlan(listString)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto retData = new ImplementOverwriteDelTargetContReportTimerTaskPlanComRespDto();





return retData;
  }
/**
   * D3分析回写目标内容自定义汇报(公共)[9452]
   * gen by moon at 4/27/2024, 2:18:51 AM
   */
  @Trace(operationName = "D3分析回写目标内容自定义汇报(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisOverwriteTargetContCustomReportComRespDto analysisOverwriteTargetContCustomReportCom(AnalysisOverwriteTargetContCustomReportComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getEvaObjTargetCycleList() !=null && reqDto.getEvaObjTargetCycleList().size()>0)) {
        //if(D3分析回写目标内容自定义汇报(公共).被评对象目标周期列表数据集条数 大于 0)  67558

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: reqDto.getEvaObjTargetCycleList()){

QueryEvaObjTargetCyclePlatformDetailComRespDto queryEvaObjTargetCyclePlatformDetailComRespDto = null;
    QueryEvaObjTargetCyclePlatformDetailComReqDto queryEvaObjTargetCyclePlatformDetailComReqDto=new QueryEvaObjTargetCyclePlatformDetailComReqDto();
  queryEvaObjTargetCyclePlatformDetailComReqDto.setIsArchive("FALSE");//sourceId:1756845_1_67561
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1756844_1_67561
    }
if(reqDto!=null){
      queryEvaObjTargetCyclePlatformDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756846_1_67561
    }

    /*D3查当前子周期牌目标计划开始时间与结束时间[8528]   */
    Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaObjTargetCycleId(),"D3分析回写目标内容自定义汇报(公共)-D3查当前子周期牌目标计划开始时间与结束时间-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getEvaluationTemplateId(),"D3分析回写目标内容自定义汇报(公共)-D3查当前子周期牌目标计划开始时间与结束时间-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCyclePlatformDetailComReqDto.getIsArchive(),"D3分析回写目标内容自定义汇报(公共)-D3查当前子周期牌目标计划开始时间与结束时间-是否存档不能为空",false);
      queryEvaObjTargetCyclePlatformDetailComRespDto = targetCycleService.queryEvaObjTargetCyclePlatformDetailCom(queryEvaObjTargetCyclePlatformDetailComReqDto)/*vcase invoke isSameApp*/;



CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(circulationCollectionsRes!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(circulationCollectionsRes.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1756841_1_67562
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1756843_1_67562
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(circulationCollectionsRes!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(circulationCollectionsRes.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1756841_1_67563
    }
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(queryEvaObjTargetCyclePlatformDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1756843_1_67563
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3分析回写目标内容自定义汇报(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((!(checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))||!(checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))) {
        //if((D2子周期成果汇报开始时间与目标计划开始时间对比（A）.时间比较结果 不等于 当前（等于） or D2子周期成果汇报结束时间与目标计划结束时间对比（B）.时间比较结果 不等于 当前（等于）))  67566

ImplementAmendTargetContIsCustomReportComRespDto implementAmendTargetContIsCustomReportComRespDto = null;
    if(queryEvaObjTargetCyclePlatformDetailComRespDto !=null){
          ImplementAmendTargetContIsCustomReportComReqDto implementAmendTargetContIsCustomReportComReqDto=new ImplementAmendTargetContIsCustomReportComReqDto();
  implementAmendTargetContIsCustomReportComReqDto.setIsOpenCustomReport("TRUE");//sourceId:1756852_1_67571
if(queryEvaObjTargetCyclePlatformDetailComRespDto!=null){
      implementAmendTargetContIsCustomReportComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1756849_1_67571
implementAmendTargetContIsCustomReportComReqDto.setTargetCycleContentId(queryEvaObjTargetCyclePlatformDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1756850_1_67571
    }
if(reqDto!=null){
      implementAmendTargetContIsCustomReportComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1756851_1_67571
    }

    /*D3回写目标内容开启自定义汇报(公共)[6893]   */
    Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getIsOpenCustomReport(),"D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-是否开启自定义汇报不能为空",false);
Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getTargetCycleContentTypeCode(),"D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getTargetCycleContentId(),"D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAmendTargetContIsCustomReportComReqDto.getEvaluationTemplateId(),"D3分析回写目标内容自定义汇报(公共)-D3回写目标内容开启自定义汇报(公共)-冗余评价模板ID不能为空",false);
      implementAmendTargetContIsCustomReportComRespDto = indexSystemService.implementAmendTargetContIsCustomReportCom(implementAmendTargetContIsCustomReportComReqDto)/*vcase invoke isSameApp*/;



           }
      }
//ModelCode: circulationEnd
        }

      }
AnalysisOverwriteTargetContCustomReportComRespDto retData = new AnalysisOverwriteTargetContCustomReportComRespDto();





return retData;
  }
/**
   * D3分析裁剪子周期汇报时间类型(公共)[9456]
   * gen by moon at 4/28/2024, 1:34:24 AM
   */
  @Trace(operationName = "D3分析裁剪子周期汇报时间类型(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisCutCycleReportTimeTypeCodeComRespDto analysisCutCycleReportTimeTypeCodeCom(AnalysisCutCycleReportTimeTypeCodeComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_3 =null;
//virtualUsage M3约定裁剪子周期汇报时间类型  67622
      //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("LESS_THAN_YEAR");//CUSTOM_CONVENTION//sourceId:1760278_1_67622
receptionServiceReq.setCustomField2("EQUAL_TO_YEAR");//CUSTOM_CONVENTION//sourceId:1760279_1_67622
receptionServiceReq.setCustomField3("SPECIAL_SUB_CYCLE_TYPES");//CUSTOM_CONVENTION//sourceId:1760280_1_67622

    /*M3约定裁剪子周期汇报时间类型[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析裁剪子周期汇报时间类型(公共)-M3约定裁剪子周期汇报时间类型-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析裁剪子周期汇报时间类型(公共)-M3约定裁剪子周期汇报时间类型-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3分析裁剪子周期汇报时间类型(公共)-M3约定裁剪子周期汇报时间类型-自定义字段3不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq);



//virtualUsage D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）  67619
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SPACE_CREATE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1760283_1_67619
queryConfItemMatchAnswerDetailComReqDto.setConfSchemeCode("COM_CONF_SCHEME");//CUSTOM_CONVENTION//sourceId:1760284_1_67619
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:1760262_1_67619
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfOptionCode(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1760267_1_67619
    }

    /*D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfOptionCode(),"D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-选项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeCode(),"D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-配置方案标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3分析裁剪子周期汇报时间类型(公共)-D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&& queryConfItemMatchAnswerDetailComRespDto.getOptionResultId() != null )) {
        //if(D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）.答案ID 值不等于空 )  67620

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setCutCycleReportTimeTypeCode(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1759912_1_67621
    }

    /*M3接收裁剪子周期汇报时间类型出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCutCycleReportTimeTypeCode(),"D3分析裁剪子周期汇报时间类型(公共)-M3接收裁剪子周期汇报时间类型出参-裁剪子周期汇报时间类型编码不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((queryConfItemMatchAnswerDetailComRespDto!= null&& queryConfItemMatchAnswerDetailComRespDto.getOptionResultId() == null )){
       //elseif(D2查入参子周期类型是否平台开启的自定义周期类型答案（公共）.答案ID 值等于空 )  67623

if((reqDto!= null&&  reqDto.getSubcycleType() !=null && reqDto.getSubcycleType().equals("YEAR"))) {
        //if(D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 年)  67626

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_2=new ImplementFiveReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setCutCycleReportTimeTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1759912_1_67627
    }

    /*M3接收裁剪子周期汇报时间类型出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCutCycleReportTimeTypeCode(),"D3分析裁剪子周期汇报时间类型(公共)-M3接收裁剪子周期汇报时间类型出参-裁剪子周期汇报时间类型编码不能为空",false);
      receptionServiceRes_4 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
      }
else if((reqDto!= null&&  reqDto.getSubcycleType() !=null && reqDto.getSubcycleType().equals("HALF_YEAR")||reqDto!= null&&  reqDto.getSubcycleType() !=null && reqDto.getSubcycleType().equals("QUARTER")||reqDto!= null&&  reqDto.getSubcycleType() !=null && reqDto.getSubcycleType().equals("DOUBLE_MOONS")||reqDto!= null&&  reqDto.getSubcycleType() !=null && reqDto.getSubcycleType().equals("MONTH")||reqDto!= null&&  reqDto.getSubcycleType() !=null && reqDto.getSubcycleType().equals("DOUBLE_WEEKS"))){
       //elseif((D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 半年 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 季度 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 双月 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 月 or D3分析裁剪子周期汇报时间类型(公共).子周期周期类型 等于 双周))  67628

//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_3=new ImplementFiveReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setCutCycleReportTimeTypeCode(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1759912_1_67629
    }

    /*M3接收裁剪子周期汇报时间类型出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getCutCycleReportTimeTypeCode(),"D3分析裁剪子周期汇报时间类型(公共)-M3接收裁剪子周期汇报时间类型出参-裁剪子周期汇报时间类型编码不能为空",false);
      receptionServiceRes_5 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
    }
AnalysisCutCycleReportTimeTypeCodeComRespDto retData = new AnalysisCutCycleReportTimeTypeCodeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setCutCycleReportTimeTypeCode(receptionServiceRes_3.getCutCycleReportTimeTypeCode());//SimpleFieldAssign//sourceId:1760292_1
    }




return retData;
  }
/**
   * D3查询自定义汇报工作周期列表(公共)[9458]
   * gen by moon at 4/28/2024, 2:34:16 PM
   */
  @Trace(operationName = "D3查询自定义汇报工作周期列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryCustomReportWorkCycleListComRespDto queryCustomReportWorkCycleListCom(QueryCustomReportWorkCycleListComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_2 =null;
//步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761175_1
receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761174_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761163_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761164_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjEntityId(),"D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-被评对象内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTypeCode(),"D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-被评对象类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询自定义汇报工作周期列表(公共)-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementEightReceivingField(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1761170_1
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1761172_1
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761167_1
queryEvaObjTargetCycleListReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761173_1
queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761169_1
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761171_1
    }

    /*3-3-09查目标子周期列表[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标子周期列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: 3-3-08批量查询目标周期规划设置 - batchQueryTargetCyclePset
     List<OmsTargetCyclePlanSet> listOmsTargetCyclePlanSet =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryTargetCyclePsetReq batchQueryTargetCyclePsetReq=new BatchQueryTargetCyclePsetReq();
  batchQueryTargetCyclePsetReq.setIsArchive("FALSE");//sourceId:1760998_1
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryTargetCyclePsetReq.setTargetCyclePsetList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1760995_1
    }
if(reqDto!=null){
      batchQueryTargetCyclePsetReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760996_1
batchQueryTargetCyclePsetReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1760996_1
    }

    /*3-3-08批量查询目标周期规划设置[4120]   */
    Assert.isNull(batchQueryTargetCyclePsetReq.getEvaluationTemplateId(),"D3查询自定义汇报工作周期列表(公共)-3-3-08批量查询目标周期规划设置-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCyclePsetReq.getEvaluationTemplateId(),"D3查询自定义汇报工作周期列表(公共)-3-3-08批量查询目标周期规划设置-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCyclePsetReq.getIsArchive(),"D3查询自定义汇报工作周期列表(公共)-3-3-08批量查询目标周期规划设置-是否存档不能为空",false);
      listOmsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.batchQueryTargetCyclePset(batchQueryTargetCyclePsetReq)/*vcase invoke 本地 method 方法调用;*/;



           }

//步骤3: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1761184_1
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1761186_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761181_1
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761182_1
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761183_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761185_1
    }

    /*3-3-09查目标内容父周期ID[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容父周期ID-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤4: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsMetaphase("TRUE");//sourceId:1761531_1
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1761533_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1761528_1
queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1761529_1
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1761530_1
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1761532_1
    }

    /*3-3-09查目标内容中期ID[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsMetaphase(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-是否中期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3查询自定义汇报工作周期列表(公共)-3-3-09查目标内容中期ID-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;




//步骤5: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
    if(listOmsTargetCyclePlanSet !=null&& !CollectionUtil.isEmpty(listOmsTargetCyclePlanSet)&& listOmsTargetCyclePlanSet.size()>0 ){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(listOmsTargetCyclePlanSet!= null&& !CollectionUtil.isEmpty(listOmsTargetCyclePlanSet)&&  listOmsTargetCyclePlanSet !=null&& !CollectionUtil.isEmpty(listOmsTargetCyclePlanSet)){
      receptionServiceReq_1.setTargetContPlanWorkTimeList(listOmsTargetCyclePlanSet.stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1761537_1
    }
if(omsEvaluationObjectTargetCycle!=null){
      receptionServiceReq_1.setTargetCycleParentCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1761543_1
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      receptionServiceReq_1.setTargetCycleMidCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1761544_1
    }

    /*M3接收出参字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetCycleParentCycleId(),"D3查询自定义汇报工作周期列表(公共)-M3接收出参字段-目标周期父周期ID不能为空",false);
      receptionServiceRes_1 = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

QueryCustomReportWorkCycleListComRespDto retData = new QueryCustomReportWorkCycleListComRespDto();
  if(receptionServiceRes_2!=null){
      retData.setTargetContPlanWorkTimeList(receptionServiceRes_2.getTargetContPlanWorkTimeList().stream().map(item -> BeanUtil.toBean(item, TargetContPlanWorkTimeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1761547_1
retData.setTargetCycleParentCycleId(receptionServiceRes_2.getTargetCycleParentCycleId());//SimpleFieldAssign//sourceId:1761548_1
retData.setTargetCycleMidCycleId(receptionServiceRes_2.getTargetCycleMidCycleId());//SimpleFieldAssign//sourceId:1761549_1
    }




return retData;
  }
/**
   * D3分析同一场景下当前子周期(公共)[9461]
   * gen by moon at 9/25/2024, 9:58:29 PM
   */
  @Trace(operationName = "D3分析同一场景下当前子周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisSameSceneCurrentSubCycleComRespDto analysisSameSceneCurrentSubCycleCom(AnalysisSameSceneCurrentSubCycleComReqDto reqDto){


      //virtualUsage 3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)  67644
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjectTargetCycleByCreateTimeDetailReq queryEvaObjectTargetCycleByCreateTimeDetailReq=new QueryEvaObjectTargetCycleByCreateTimeDetailReq();
  queryEvaObjectTargetCycleByCreateTimeDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762595_1_67644
queryEvaObjectTargetCycleByCreateTimeDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1762596_1_67644
queryEvaObjectTargetCycleByCreateTimeDetailReq.setTargetCycleContentTypeCode("TARGET");//sourceId:1763380_1_67644
queryEvaObjectTargetCycleByCreateTimeDetailReq.setIsArchive("FALSE");//sourceId:1762599_1_67644
queryEvaObjectTargetCycleByCreateTimeDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1762601_1_67644
if(reqDto!=null){
      queryEvaObjectTargetCycleByCreateTimeDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1763396_1_67644
queryEvaObjectTargetCycleByCreateTimeDetailReq.setPlanningType(reqDto.getPlanningType());//SimpleFieldAssign//sourceId:1762597_1_67644
    }

    /*3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)[9462]   */
    Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getCycleStartTime(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-目标计划开始时间不能为空",false);
Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getCycleEndTime(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-目标计划结束时间不能为空",false);
Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getTargetCycleContentTypeCode(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getEvaObjTypeCode(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getPlanningType(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-冗余规划类型不能为空",false);
Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getIsArchive(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-是否存档不能为空",false);
Assert.isNull(queryEvaObjectTargetCycleByCreateTimeDetailReq.getSpaceId(),"D3分析同一场景下当前子周期(公共)-3-3-09查询被评对象目标周期详情(按评价模板创建时间排序)-创建于空间ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjectTargetCycleByCreateTimeDetail(queryEvaObjectTargetCycleByCreateTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle != null )) {
        //if(3-3-09查最新一条当前子周期ID（同一规划类型）.出参 值不等于空 )  67646

ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto=new ImplementStringEfficiencyCheckComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      implementStringEfficiencyCheckComReqDto.setReferenceString(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1762609_1_67653
    }
if(reqDto!=null){
      implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1762610_1_67653
    }

    /*D2-执行字符串对比(公共)[5774]   */
    Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(),"D3分析同一场景下当前子周期(公共)-D2-执行字符串对比(公共)-参照字符串不能为空",false);
Assert.isNull(implementStringEfficiencyCheckComReqDto.getComparisonString(),"D3分析同一场景下当前子周期(公共)-D2-执行字符串对比(公共)-对比字符串不能为空",false);
      implementStringEfficiencyCheckComRespDto = fwCompInterfaceModeClient.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(implementStringEfficiencyCheckComRespDto== null||  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() ==null,"找不到数据，系统异常",false);


           }
if((implementStringEfficiencyCheckComRespDto!= null&&  implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() !=null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
        //if(D2-对比入参子周期ID与当前子周期ID是否相同.字符串对比结果 等于 是)  67655

List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    QueryExecuteCycleStageTestListReq queryExecuteCycleStageTestListReq=new QueryExecuteCycleStageTestListReq();
  queryExecuteCycleStageTestListReq.setIsSameSceneCurrentSubCycle("TRUE");//sourceId:1763757_1_67662
queryExecuteCycleStageTestListReq.setIsArchive("FALSE");//sourceId:1763758_1_67662
queryExecuteCycleStageTestListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1763759_1_67662

    /*3-3-07查询执行周期阶段列表[4288]   */
    Assert.isNull(queryExecuteCycleStageTestListReq.getIsSameSceneCurrentSubCycle(),"D3分析同一场景下当前子周期(公共)-3-3-07查询执行周期阶段列表-是否规划类型内子周期当前不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getIsArchive(),"D3分析同一场景下当前子周期(公共)-3-3-07查询执行周期阶段列表-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageTestListReq.getSpaceId(),"D3分析同一场景下当前子周期(公共)-3-3-07查询执行周期阶段列表-创建于空间ID不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageTestList(queryExecuteCycleStageTestListReq)/*vcase invoke 本地 method 方法调用;*/;



List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          BatchQueryEvaObjTargetCycleReq batchQueryEvaObjTargetCycleReq=new BatchQueryEvaObjTargetCycleReq();
  batchQueryEvaObjTargetCycleReq.setIsArchive("FALSE");//sourceId:1763788_1_67664
if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      batchQueryEvaObjTargetCycleReq.setEvaObjTargetCycleList(listOmsExecuteCycleStage.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1763787_1_67664
    }
if(reqDto!=null){
      batchQueryEvaObjTargetCycleReq.setPlanningType(reqDto.getPlanningType());//SimpleFieldAssign//sourceId:1763791_1_67664
    }

    /*3-3-09批量查被评对象目标周期列表[2335]   */
    Assert.isNull(batchQueryEvaObjTargetCycleReq.getPlanningType(),"D3分析同一场景下当前子周期(公共)-3-3-09批量查被评对象目标周期列表-冗余规划类型不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleReq.getIsArchive(),"D3分析同一场景下当前子周期(公共)-3-3-09批量查被评对象目标周期列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryEvaObjTargetCycle(batchQueryEvaObjTargetCycleReq)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 =new ArrayList<>();
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryExecuteCycleStageListByTargetCycleIdsReq batchQueryExecuteCycleStageListByTargetCycleIdsReq=new BatchQueryExecuteCycleStageListByTargetCycleIdsReq();
  batchQueryExecuteCycleStageListByTargetCycleIdsReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1763795_1_67665
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryExecuteCycleStageListByTargetCycleIdsReq.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1763792_1_67665
    }

    /*3-3-07-批量查询执行周期阶段列表By目标周期ID[6508]   */
    Assert.isNull(batchQueryExecuteCycleStageListByTargetCycleIdsReq.getSubjectLifeCycle(),"D3分析同一场景下当前子周期(公共)-3-3-07-批量查询执行周期阶段列表By目标周期ID-主体生命周期不能为空",false);
      listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.batchQueryExecuteCycleStageListByTargetCycleIds(batchQueryExecuteCycleStageListByTargetCycleIdsReq)/*vcase invoke 本地 method 方法调用;*/;



           }
if((listOmsExecuteCycleStage_2!= null&&  listOmsExecuteCycleStage_2 !=null && listOmsExecuteCycleStage_2.size()>1)) {
        //if(3-3-07-查最终执行周期阶段列表（规划下当前子周期执行周期阶段）.执行周期阶段列表数据集条数 大于 1)  67667

//异常结束 67668
      throw new BizException("undefined","undefined",false);
      }
boolean bOOLEAN ;
    if(listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&& listOmsExecuteCycleStage_2.size()>0 ){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4=new ArrayList<>();
  if(listOmsExecuteCycleStage_2!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&&  listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)){
      listOmsExecuteCycleStage_4 = //objList-to-objLists
        listOmsExecuteCycleStage_2.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:355471_2_67666
elm.setIsSameSceneCurrentSubCycle("FALSE");//sourceId:355473_2_67666
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1763799_1_67666
    }

    /*3-3-07批量改执行周期阶段[3150]   */

      bOOLEAN = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_4)/*vcase invoke 本地 method 方法调用;*/;



           }
boolean bOOLEAN_1 ;
    OmsExecuteCycleStage omsExecuteCycleStage=new OmsExecuteCycleStage();
  omsExecuteCycleStage.setIsSameSceneCurrentSubCycle("TRUE");//sourceId:1762995_1_67659
if(reqDto!=null){
      omsExecuteCycleStage.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1762994_1_67659
    }

    /*3-3-07修改执行周期阶段[2489]   */
    Assert.isNull(omsExecuteCycleStage.getExecuteCycleStageId(),"D3分析同一场景下当前子周期(公共)-3-3-07修改执行周期阶段-执行周期阶段ID不能为空",false);
Assert.isNull(omsExecuteCycleStage.getIsSameSceneCurrentSubCycle(),"D3分析同一场景下当前子周期(公共)-3-3-07修改执行周期阶段-是否规划类型内子周期当前不能为空",false);
      bOOLEAN_1 = mOmsExecuteCycleStageService.updateExecuteCycleStage(omsExecuteCycleStage)/*vcase invoke 本地 method 方法调用;*/;



      }
      }
AnalysisSameSceneCurrentSubCycleComRespDto retData = new AnalysisSameSceneCurrentSubCycleComRespDto();





return retData;
  }
/**
   * D3分析第二末级周期场景裁减时间(公共)[9463]
   * gen by moon at 4/30/2024, 11:42:00 AM
   */
  @Trace(operationName = "D3分析第二末级周期场景裁减时间(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisReferenceTimeSecondCycleComRespDto analysisReferenceTimeSecondCycleCom(AnalysisReferenceTimeSecondCycleComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D3查评价模板使用的配置方案ID(公共)  67680
      QueryEvaTempDetailComRespDto queryEvaTempDetailComRespDto = null;
    QueryEvaTempDetailComReqDto queryEvaTempDetailComReqDto=new QueryEvaTempDetailComReqDto();
  queryEvaTempDetailComReqDto.setIsArchive("FALSE");//sourceId:1764580_1_67680
if(reqDto!=null){
      queryEvaTempDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764577_1_67680
    }

    /*D3查评价模板使用的配置方案ID(公共)[8468]   */
    Assert.isNull(queryEvaTempDetailComReqDto.getEvaluationTemplateId(),"D3分析第二末级周期场景裁减时间(公共)-D3查评价模板使用的配置方案ID(公共)-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailComReqDto.getIsArchive(),"D3分析第二末级周期场景裁减时间(公共)-D3查评价模板使用的配置方案ID(公共)-是否存档不能为空",false);
      queryEvaTempDetailComRespDto = evaThemeService.queryEvaTempDetailCom(queryEvaTempDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D2查第二末级周期场景裁减参照周期类型配置答案  67654
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(queryEvaTempDetailComRespDto !=null){
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SECOND_LAST_CYCLE_REFERENCE_REDUCE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:1763366_1_67654
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("TRUE");//sourceId:1763367_1_67654
if(queryEvaTempDetailComRespDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setConfSchemeId(queryEvaTempDetailComRespDto.getConfSchemeId());//SimpleFieldAssign//sourceId:1764575_1_67654
    }

    /*D2查第二末级周期场景裁减参照周期类型配置答案[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfSchemeId(),"D3分析第二末级周期场景裁减时间(公共)-D2查第二末级周期场景裁减参照周期类型配置答案-配置方案ID 不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3分析第二末级周期场景裁减时间(公共)-D2查第二末级周期场景裁减参照周期类型配置答案-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3分析第二末级周期场景裁减时间(公共)-D2查第二末级周期场景裁减参照周期类型配置答案-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryConfItemMatchAnswerDetailComRespDto!= null&& queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null &&!(queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("DISABLE")))) {
        //if((D2查第二末级周期场景裁减参照周期类型配置标准答案（公共）.答案值 值不等于空  and D2查第二末级周期场景裁减参照周期类型配置标准答案（公共）.答案值 不等于 不启用))  67658

OmsExecuteCycleStage omsExecuteCycleStage = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          QueryExecuteCycleEqualStartrAndGreateDetailReq queryExecuteCycleEqualStartrAndGreateDetailReq=new QueryExecuteCycleEqualStartrAndGreateDetailReq();
  queryExecuteCycleEqualStartrAndGreateDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1763382_1_67661
queryExecuteCycleEqualStartrAndGreateDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1763383_1_67661
queryExecuteCycleEqualStartrAndGreateDetailReq.setIsArchive("FALSE");//sourceId:1763386_1_67661
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      queryExecuteCycleEqualStartrAndGreateDetailReq.setCycleTypeCode(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1763390_1_67661
    }
if(reqDto!=null){
      queryExecuteCycleEqualStartrAndGreateDetailReq.setRelateContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1763384_1_67661
queryExecuteCycleEqualStartrAndGreateDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1763385_1_67661
queryExecuteCycleEqualStartrAndGreateDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1763387_1_67661
    }

    /*3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）[9464]   */
    Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getCycleStartTime(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getCycleEndTime(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getCycleTypeCode(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-周期类型标识不能为空",false);
Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getRelateContentTypeCode(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-关联目标内容类型编码不能为空",false);
Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getEvaluationTemplateId(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getIsArchive(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleEqualStartrAndGreateDetailReq.getSpaceId(),"D3分析第二末级周期场景裁减时间(公共)-3-3-07查当前时间匹配的执行周期开始时间（入参裁减参照周期类型）-创建于空间ID不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleEqualStartrAndGreateDetail(queryExecuteCycleEqualStartrAndGreateDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    if(omsExecuteCycleStage !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(omsExecuteCycleStage!=null){
      receptionServiceReq.setComTimeField(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:1763763_1_67663
    }

    /*M3接收参照时间出参[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getComTimeField(),"D3分析第二末级周期场景裁减时间(公共)-M3接收参照时间出参-通用时间字段不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
AnalysisReferenceTimeSecondCycleComRespDto retData = new AnalysisReferenceTimeSecondCycleComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setComTimeField(receptionServiceRes_1.getComTimeField());//SimpleFieldAssign//sourceId:1763765_1
    }




return retData;
  }
/**
   * D3更新子周期为规划下当前(公共)[9465]
   * gen by moon at 5/3/2024, 8:05:59 PM
   */
  @Trace(operationName = "D3更新子周期为规划下当前(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public TimingRefreshSubCycleIsPlanCurrentComRespDto timingRefreshSubCycleIsPlanCurrentCom(TimingRefreshSubCycleIsPlanCurrentComReqDto reqDto){


      //步骤0: M3执行第八接收字段（特殊方法） - implementEightReceivingField
     //ModelCode: receptionService
        ImplementEightReceivingFieldRespDto receptionServiceRes = null;
    ImplementEightReceivingFieldReqDto receptionServiceReq=new ImplementEightReceivingFieldReqDto();
  if(reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(reqDto.getExecuteCycleStageList())){
      receptionServiceReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1764234_1
    }
if(reqDto!=null){
      receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764244_1
    }

    /*M3接收入参字段[8691]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3更新子周期为规划下当前(公共)-M3接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementEightReceivingField(receptionServiceReq);




//步骤1: M3-执行执行周期阶段【循环开始】 - implementExecCycleStageLoopStart
     //ModelCode: circulationCollections
        for (ExecuteCycleStageDto circulationCollectionsRes: reqDto.getExecuteCycleStageList()){


//步骤2: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1764241_1
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1764239_1
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764240_1
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3更新子周期为规划下当前(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3更新子周期为规划下当前(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3更新子周期为规划下当前(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤3: D3分析同一场景下当前子周期(公共) - analysisSameSceneCurrentSubCycleCom
     AnalysisSameSceneCurrentSubCycleComRespDto analysisSameSceneCurrentSubCycleComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          AnalysisSameSceneCurrentSubCycleComReqDto analysisSameSceneCurrentSubCycleComReqDto=new AnalysisSameSceneCurrentSubCycleComReqDto();
  if(circulationCollectionsRes!=null){
      analysisSameSceneCurrentSubCycleComReqDto.setExecuteCycleStageId(circulationCollectionsRes.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1763810_1
analysisSameSceneCurrentSubCycleComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1763808_1
    }
if(omsEvaluationObjectTargetCycle!=null){
      analysisSameSceneCurrentSubCycleComReqDto.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1763811_1
analysisSameSceneCurrentSubCycleComReqDto.setPlanningType(omsEvaluationObjectTargetCycle.getPlanningType());//SimpleFieldAssign//sourceId:1763809_1
    }

    /*D3分析同一场景下当前子周期(公共)[9461]   */
    Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getExecuteCycleStageId(),"D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-执行周期阶段ID不能为空",false);
Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getEvaObjTargetCycleId(),"D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getEvaObjTypeCode(),"D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-被评对象类型编码不能为空",false);
Assert.isNull(analysisSameSceneCurrentSubCycleComReqDto.getPlanningType(),"D3更新子周期为规划下当前(公共)-D3分析同一场景下当前子周期(公共)-冗余规划类型不能为空",false);
      analysisSameSceneCurrentSubCycleComRespDto = analysisSameSceneCurrentSubCycleCom(analysisSameSceneCurrentSubCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }

//步骤4: M3-执行【循环结束】 - implementLoopEnd
     //ModelCode: circulationEnd
        }


TimingRefreshSubCycleIsPlanCurrentComRespDto retData = new TimingRefreshSubCycleIsPlanCurrentComRespDto();





return retData;
  }
/**
   * D3执行子周期最大双周推内存(公共)[9771]
   * gen by moon at 6/9/2024, 4:35:18 PM
   */
  @Trace(operationName = "D3执行子周期最大双周推内存(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSubCycleBigDubbleWeeksMemoryComRespDto implementSubCycleBigDubbleWeeksMemoryCom(ImplementSubCycleBigDubbleWeeksMemoryComReqDto reqDto){


      //virtualUsage D2执行数据集取一条（含时间）(公共)  69823
      ImplementDatasFetchLastLatestWithTimeComRespDto implementDatasFetchLastLatestWithTimeComRespDto = null;
    ImplementDatasFetchLastLatestWithTimeComReqDto implementDatasFetchLastLatestWithTimeComReqDto=new ImplementDatasFetchLastLatestWithTimeComReqDto();
  implementDatasFetchLastLatestWithTimeComReqDto.setOrderSizeType("FROM_LARGE_SMALL");//sourceId:1860670_1_69823
if(reqDto!= null&&  reqDto.getCycleList() !=null&& !CollectionUtil.isEmpty(reqDto.getCycleList())){
      implementDatasFetchLastLatestWithTimeComReqDto.setComDatasList(//objList-to-objLists
        reqDto.getCycleList().stream().map(item -> {
      ComDatasDto elm = new ComDatasDto();
      if(item!=null){
      elm.setCustomField1(item.getCycleStandardName());//SimpleFieldAssign//sourceId:372460_2_69823
elm.setComTimeField1(item.getCycleStartTime());//SimpleFieldAssign//sourceId:372703_2_69823
elm.setComTimeField2(item.getCycleEndTime());//SimpleFieldAssign//sourceId:372704_2_69823
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1858610_1_69823
    }

    /*D2执行数据集取一条（含时间）(公共)[9774]   */
    Assert.isNull(implementDatasFetchLastLatestWithTimeComReqDto.getOrderSizeType(),"D3执行子周期最大双周推内存(公共)-D2执行数据集取一条（含时间）(公共)-排序大小类型不能为空",false);
      implementDatasFetchLastLatestWithTimeComRespDto = fwCompInterfaceModeClient.implementDatasFetchLastLatestWithTimeCom(implementDatasFetchLastLatestWithTimeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D2执行时间格式转换(公共)  69821
      ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
    if(implementDatasFetchLastLatestWithTimeComRespDto !=null){
          ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto=new ImplementTimeFormatConversionComReqDto();
  if(implementDatasFetchLastLatestWithTimeComRespDto!=null){
      implementTimeFormatConversionComReqDto.setComTxtField(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField1()!=null?String.valueOf(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField1()):"");//SimpleFieldAssign//sourceId:1858045_1_69821
    }

    /*D2执行时间格式转换(公共)[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(),"D3执行子周期最大双周推内存(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto = fwCompInterfaceModeClient.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D2执行时间格式转换(公共)  69820
      ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
    if(implementDatasFetchLastLatestWithTimeComRespDto !=null){
          ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1=new ImplementTimeFormatConversionComReqDto();
  if(implementDatasFetchLastLatestWithTimeComRespDto!=null){
      implementTimeFormatConversionComReqDto_1.setComTxtField(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField2()!=null?String.valueOf(implementDatasFetchLastLatestWithTimeComRespDto.getComTimeField2()):"");//SimpleFieldAssign//sourceId:1858045_1_69820
    }

    /*D2执行时间格式转换(公共)[9757]   */
    Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(),"D3执行子周期最大双周推内存(公共)-D2执行时间格式转换(公共)-通用文本字段不能为空",false);
      implementTimeFormatConversionComRespDto_2 = fwCompInterfaceModeClient.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D3新增内存业务数据(业务原子)  69822
      AddMemoryBusinessSetDataComRespDto addMemoryBusinessSetDataComRespDto = null;
    if(implementDatasFetchLastLatestWithTimeComRespDto !=null&&implementTimeFormatConversionComRespDto !=null&&implementTimeFormatConversionComRespDto_2 !=null){
          AddMemoryBusinessSetDataComReqDto addMemoryBusinessSetDataComReqDto=new AddMemoryBusinessSetDataComReqDto();
  addMemoryBusinessSetDataComReqDto.setIsDataList("FALSE");//sourceId:1858042_1_69822
addMemoryBusinessSetDataComReqDto.setCustomField1("evaObjTargetCycleId");//CUSTOM_CONVENTION//sourceId:1858043_1_69822
addMemoryBusinessSetDataComReqDto.setCustomField2("cycleStandardName");//CUSTOM_CONVENTION//sourceId:1858244_1_69822
addMemoryBusinessSetDataComReqDto.setCustomField3("cycleStartTime");//CUSTOM_CONVENTION//sourceId:1858252_1_69822
addMemoryBusinessSetDataComReqDto.setCustomField4("cycleEndTime");//CUSTOM_CONVENTION//sourceId:1858624_1_69822
if(reqDto!=null){
      addMemoryBusinessSetDataComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1858041_1_69822
addMemoryBusinessSetDataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1858040_1_69822
addMemoryBusinessSetDataComReqDto.setCustomFieldValue1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1858044_1_69822
    }
if(implementDatasFetchLastLatestWithTimeComRespDto!=null){
      addMemoryBusinessSetDataComReqDto.setCustomFieldValue2(implementDatasFetchLastLatestWithTimeComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1858245_1_69822
    }
if(implementTimeFormatConversionComRespDto!=null){
      addMemoryBusinessSetDataComReqDto.setCustomFieldValue3(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1858253_1_69822
    }
if(implementTimeFormatConversionComRespDto_2!=null){
      addMemoryBusinessSetDataComReqDto.setCustomFieldValue4(implementTimeFormatConversionComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1858625_1_69822
    }

    /*D3新增内存业务数据(业务原子)[8643]   */
    Assert.isNull(addMemoryBusinessSetDataComReqDto.getBusinessDataObject(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-业务数据对象不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getDataObjectBatchCode(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-数据对象批次标识不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getIsDataList(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-是否是数据集对象不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField1(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段1不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue1(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值1不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField2(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段2不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue2(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值2不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField3(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段3不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue3(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值3不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomField4(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段4不能为空",false);
Assert.isNull(addMemoryBusinessSetDataComReqDto.getCustomFieldValue4(),"D3执行子周期最大双周推内存(公共)-D3新增内存业务数据(业务原子)-自定义字段值4不能为空",false);
      addMemoryBusinessSetDataComRespDto = businessAtomService.addMemoryBusinessSetDataCom(addMemoryBusinessSetDataComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementSubCycleBigDubbleWeeksMemoryComRespDto retData = new ImplementSubCycleBigDubbleWeeksMemoryComRespDto();





return retData;
  }
/**
   * D3分析子周期双周周期开始时间(公共)[9772]
   * gen by moon at 6/9/2024, 4:35:41 PM
   */
  @Trace(operationName = "D3分析子周期双周周期开始时间(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisSubCycleBiweeklyStartTimeComRespDto analysisSubCycleBiweeklyStartTimeCom(AnalysisSubCycleBiweeklyStartTimeComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D2两个时间对比（公共）  69832
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1859411_1_69832
checkTimeScopeSearchComReqDto.setCompareTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859413_1_69832
    }

    /*D2两个时间对比（公共）[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))) {
        //if(D2父周期开始时间与子周期开始时间对比（用于判断是否相同）.时间比较结果 等于 当前（等于）)  69833

OmsCycle omsCycle = null;
    QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq=new QueryTimeRangeFindCycleDetailReq();
  queryTimeRangeFindCycleDetailReq.setCycleTypeCode("WEEK");//CUSTOM_CONVENTION//sourceId:1859418_1_69839
queryTimeRangeFindCycleDetailReq.setPlatformData("TRUE");//sourceId:1859419_1_69839
queryTimeRangeFindCycleDetailReq.setIsArchive("FALSE");//sourceId:1860698_1_69839
if(reqDto!=null){
      queryTimeRangeFindCycleDetailReq.setCycleStartTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859416_1_69839
queryTimeRangeFindCycleDetailReq.setCycleEndTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859417_1_69839
    }

    /*3-4-04查子周期开始第一周周期[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleStartTime(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleEndTime(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getCycleTypeCode(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getPlatformData(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否是平台不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq.getIsArchive(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否存档不能为空",false);
      omsCycle = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    if(omsCycle !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(omsCycle!=null){
      receptionServiceReq.setCycleId(omsCycle.getCycleId());//SimpleFieldAssign//sourceId:1859633_1_69841
receptionServiceReq.setCycleStartTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1859635_1_69841
receptionServiceReq.setCycleEndTime(omsCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1859634_1_69841
    }

    /*M3接收周期开始时间出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCycleStartTime(),"D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getCycleEndTime(),"D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期结束时间不能为空",false);
      receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("BEFORE")||checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))){
       //elseif((D2父周期开始时间与子周期开始时间对比（用于判断是否相同）.时间比较结果 等于 之前（小于） or D2父周期开始时间与子周期开始时间对比（用于判断是否相同）.时间比较结果 等于 之后（大于）))  69834

QueryMemoryBusinessDataSetDetailComRespDto queryMemoryBusinessDataSetDetailComRespDto = null;
    QueryMemoryBusinessDataSetDetailComReqDto queryMemoryBusinessDataSetDetailComReqDto=new QueryMemoryBusinessDataSetDetailComReqDto();
  queryMemoryBusinessDataSetDetailComReqDto.setCustomField1("cycleStartTime");//CUSTOM_CONVENTION//sourceId:1858573_1_69835
queryMemoryBusinessDataSetDetailComReqDto.setCustomField2("cycleEndTime");//CUSTOM_CONVENTION//sourceId:1858574_1_69835
if(reqDto!=null){
      queryMemoryBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1858572_1_69835
queryMemoryBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1858571_1_69835
    }

    /*D3查询当前最新的子周期最后一个双周开始与结束时间（内存）[8644]   */
    Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getBusinessDataObject(),"D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-业务数据对象不能为空",false);
Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getDataObjectBatchCode(),"D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-数据对象批次标识不能为空",false);
Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getCustomField1(),"D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-自定义字段1不能为空",false);
Assert.isNull(queryMemoryBusinessDataSetDetailComReqDto.getCustomField2(),"D3分析子周期双周周期开始时间(公共)-D3查询当前最新的子周期最后一个双周开始与结束时间（内存）-自定义字段2不能为空",false);
      queryMemoryBusinessDataSetDetailComRespDto = businessAtomService.queryMemoryBusinessDataSetDetailCom(queryMemoryBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;



CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(queryMemoryBusinessDataSetDetailComRespDto !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(queryMemoryBusinessDataSetDetailComRespDto!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2()!=null?CommonFunctionHelper.str2Date(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2()):null);//SimpleFieldAssign//sourceId:1859411_1_69836
    }
if(reqDto!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859413_1_69836
    }

    /*D2两个时间对比（公共）[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3分析子周期双周周期开始时间(公共)-D2两个时间对比（公共）-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("BEFORE"))) {
        //if(D2内存中周期结束时间与子周期开始时间对比（公共）.时间比较结果 等于 之前（小于）)  69837

OmsCycle omsCycle_2 = null;
    QueryTimeRangeFindCycleDetailReq queryTimeRangeFindCycleDetailReq_1=new QueryTimeRangeFindCycleDetailReq();
  queryTimeRangeFindCycleDetailReq_1.setCycleTypeCode("WEEK");//CUSTOM_CONVENTION//sourceId:1859418_1_69840
queryTimeRangeFindCycleDetailReq_1.setPlatformData("TRUE");//sourceId:1859419_1_69840
queryTimeRangeFindCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1860698_1_69840
if(reqDto!=null){
      queryTimeRangeFindCycleDetailReq_1.setCycleStartTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859416_1_69840
queryTimeRangeFindCycleDetailReq_1.setCycleEndTime(reqDto.getSubCycleTargetActualStartTime());//SimpleFieldAssign//sourceId:1859417_1_69840
    }

    /*3-4-04查子周期开始第一周周期[7005]   */
    Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleStartTime(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期开始时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleEndTime(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期结束时间不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getCycleTypeCode(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-周期类型标识不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getPlatformData(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否是平台不能为空",false);
Assert.isNull(queryTimeRangeFindCycleDetailReq_1.getIsArchive(),"D3分析子周期双周周期开始时间(公共)-3-4-04查子周期开始第一周周期-是否存档不能为空",false);
      omsCycle_2 = mOmsCycleService.queryTimeRangeFindCycleDetail(queryTimeRangeFindCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsCycle_2 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(omsCycle_2!=null){
      receptionServiceReq_1.setCycleId(omsCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1859633_1_69842
receptionServiceReq_1.setCycleStartTime(omsCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1859635_1_69842
receptionServiceReq_1.setCycleEndTime(omsCycle_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1859634_1_69842
    }

    /*M3接收周期开始时间出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCycleStartTime(),"D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq_1.getCycleEndTime(),"D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期结束时间不能为空",false);
      receptionServiceRes_2 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
      }
else if((checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")||checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("LATER"))){
       //elseif((D2内存中周期结束时间与子周期开始时间对比（公共）.时间比较结果 等于 当前（等于） or D2内存中周期结束时间与子周期开始时间对比（公共）.时间比较结果 等于 之后（大于）))  69838

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    if(queryMemoryBusinessDataSetDetailComRespDto !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(queryMemoryBusinessDataSetDetailComRespDto!=null){
      receptionServiceReq_2.setCycleStartTime(queryMemoryBusinessDataSetDetailComRespDto.getCustomField1()!=null?CommonFunctionHelper.str2Date(queryMemoryBusinessDataSetDetailComRespDto.getCustomField1()):null);//SimpleFieldAssign//sourceId:1859635_1_69843
receptionServiceReq_2.setCycleEndTime(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2()!=null?CommonFunctionHelper.str2Date(queryMemoryBusinessDataSetDetailComRespDto.getCustomField2()):null);//SimpleFieldAssign//sourceId:1859634_1_69843
    }

    /*M3接收周期开始时间出参[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getCycleStartTime(),"D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq_2.getCycleEndTime(),"D3分析子周期双周周期开始时间(公共)-M3接收周期开始时间出参-周期结束时间不能为空",false);
      receptionServiceRes_3 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
    }
AnalysisSubCycleBiweeklyStartTimeComRespDto retData = new AnalysisSubCycleBiweeklyStartTimeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setCycleId(receptionServiceRes_1.getCycleId());//SimpleFieldAssign//sourceId:1859700_1
retData.setCycleStartTime(receptionServiceRes_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1859701_1
retData.setCycleEndTime(receptionServiceRes_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1859702_1
    }




return retData;
  }
/**
   * D3分析目标内容自定义过程执行周期范围(公共)[9835]
   * gen by moon at 7/10/2024, 6:45:10 PM
   */
  @Trace(operationName = "D3分析目标内容自定义过程执行周期范围(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto analysisTargetContentCustomProcessExecutionCycleRangeCom(AnalysisTargetContentCustomProcessExecutionCycleRangeComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_5 =new ArrayList<>();
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_7 =new ArrayList<>();
//virtualUsage 3-3-09查被评对象目标周期详情  70396
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1879574_1_70396
queryEvaObjTargetCycleDetailReq.setIsSubCycle("TRUE");//sourceId:1879577_1_70396
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1879579_1_70396
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1879575_1_70396
queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1879576_1_70396
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879578_1_70396
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsSubCycle(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-08查询目标周期规划设置详情  70397
      OmsTargetCyclePlanSet omsTargetCyclePlanSet = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryTargetCyclePsetDetailReq queryTargetCyclePsetDetailReq=new QueryTargetCyclePsetDetailReq();
  queryTargetCyclePsetDetailReq.setIsArchive("FALSE");//sourceId:1879568_1_70397
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetCyclePsetDetailReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879561_1_70397
    }
if(reqDto!=null){
      queryTargetCyclePsetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879566_1_70397
    }

    /*3-3-08查询目标周期规划设置详情[3368]   */
    Assert.isNull(queryTargetCyclePsetDetailReq.getEvaObjTargetCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-08查询目标周期规划设置详情-归属被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-08查询目标周期规划设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCyclePsetDetailReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-08查询目标周期规划设置详情-是否存档不能为空",false);
      omsTargetCyclePlanSet = mOmsTargetCyclePlanSetService.queryTargetCyclePsetDetail(queryTargetCyclePsetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage D2两个时间对比大小(公共)  70398
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
    if(omsTargetCyclePlanSet !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto.setCurrentTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1879475_1_70398
    }
if(omsTargetCyclePlanSet!=null){
      checkTimeScopeSearchComReqDto.setCompareTime(omsTargetCyclePlanSet.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1879477_1_70398
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(),"D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(),"D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D2两个时间对比大小(公共)  70399
      CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto_2 = null;
    if(omsTargetCyclePlanSet !=null){
          CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto_1=new CheckTimeScopeSearchComReqDto();
  if(reqDto!=null){
      checkTimeScopeSearchComReqDto_1.setCurrentTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1879475_1_70399
    }
if(omsTargetCyclePlanSet!=null){
      checkTimeScopeSearchComReqDto_1.setCompareTime(omsTargetCyclePlanSet.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1879477_1_70399
    }

    /*D2两个时间对比大小(公共)[3297]   */
    Assert.isNull(checkTimeScopeSearchComReqDto_1.getCurrentTime(),"D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-当前时间不能为空",false);
Assert.isNull(checkTimeScopeSearchComReqDto_1.getCompareTime(),"D3分析目标内容自定义过程执行周期范围(公共)-D2两个时间对比大小(公共)-比较时间不能为空",false);
      checkTimeScopeSearchComRespDto_2 = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage 3-3-07查询执行周期阶段详情  70405
      OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setIsSubCycle("TRUE");//sourceId:1879900_1_70405
queryExecuteCycleStageDetailReq.setIsProcessCycleStage("FALSE");//sourceId:1879903_1_70405
queryExecuteCycleStageDetailReq.setIsArchive("FALSE");//sourceId:1879902_1_70405
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879898_1_70405
queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1879899_1_70405
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879901_1_70405
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getEvaObjTargetCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT")&&checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT"))) {
        //if((D2目标内容的成果汇报开始时间与目标的成果汇报开始时间对比.时间比较结果 等于 当前（等于） and D2目标内容的成果汇报结束时间与目标的成果汇报结束时间对比.时间比较结果 等于 当前（等于）))  70400

List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QueryListByTimeSliceExecuteCycleStageReq queryListByTimeSliceExecuteCycleStageReq=new QueryListByTimeSliceExecuteCycleStageReq();
  queryListByTimeSliceExecuteCycleStageReq.setIsProcessCycleStage("TRUE");//sourceId:1879905_1_70403
queryListByTimeSliceExecuteCycleStageReq.setIsArchive("FALSE");//sourceId:1879907_1_70403
if(omsEvaluationObjectTargetCycle!=null){
      queryListByTimeSliceExecuteCycleStageReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879904_1_70403
    }
if(reqDto!=null){
      queryListByTimeSliceExecuteCycleStageReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879906_1_70403
    }

    /*3-3-07查询目标周期下的所有执行周期阶段列表[5982]   */
    Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getEvaObjTargetCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-被评对象目标周期ID不能为空",false);
Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getIsProcessCycleStage(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-是否过程周期阶段不能为空",false);
Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-评价模板ID不能为空",false);
Assert.isNull(queryListByTimeSliceExecuteCycleStageReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询目标周期下的所有执行周期阶段列表-是否存档不能为空",false);
      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryListByTimeSliceExecuteCycleStage(queryListByTimeSliceExecuteCycleStageReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 &&omsExecuteCycleStage !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      OmsExecuteCycleStage finalOmsExecuteCycleStage = omsExecuteCycleStage;
      receptionServiceReq.setExecuteCycleStageList(//objList-to-objLists
        listOmsExecuteCycleStage.stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:376191_2_70404
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:376193_2_70404
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:376194_2_70404
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:376195_2_70404
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:376196_2_70404
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:376197_2_70404
elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:376198_2_70404
elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:376199_2_70404
elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:376200_2_70404
elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:376201_2_70404
elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:376202_2_70404
elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:376203_2_70404
elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:376204_2_70404
elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:376205_2_70404
elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:376206_2_70404
elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:376207_2_70404
elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:376208_2_70404
elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:376209_2_70404
elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:376210_2_70404
elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:376212_2_70404
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:376213_2_70404
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:376214_2_70404
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:376219_2_70404
elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:376220_2_70404
if(reqDto!=null){
      elm.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376211_2_70404
elm.setTargetId(reqDto.getTargetId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376217_2_70404
elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376218_2_70404
    }
if(finalOmsExecuteCycleStage !=null){
      elm.setRelateContentTypeCode(finalOmsExecuteCycleStage.getRelateContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376215_2_70404
elm.setRelateContentId(finalOmsExecuteCycleStage.getRelateContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376216_2_70404
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1879897_1_70404
    }

    /*M3-接收出参数据集：执行周期阶段列表[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((!(checkTimeScopeSearchComRespDto!= null&&  checkTimeScopeSearchComRespDto.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT"))||!(checkTimeScopeSearchComRespDto_2!= null&&  checkTimeScopeSearchComRespDto_2.getTimeCompareResult() !=null && checkTimeScopeSearchComRespDto_2.getTimeCompareResult().equals("PRESENT")))){
       //elseif((D2目标内容的成果汇报开始时间与目标的成果汇报开始时间对比.时间比较结果 不等于 当前（等于） or D2目标内容的成果汇报结束时间与目标的成果汇报结束时间对比.时间比较结果 不等于 当前（等于）))  70401

List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2 =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QuerySubCycleExecuteCycleStageListReq querySubCycleExecuteCycleStageListReq=new QuerySubCycleExecuteCycleStageListReq();
  querySubCycleExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:1879990_1_70407
querySubCycleExecuteCycleStageListReq.setIsArchive("FALSE");//sourceId:1879992_1_70407
if(omsEvaluationObjectTargetCycle!=null){
      querySubCycleExecuteCycleStageListReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1879987_1_70407
    }
if(reqDto!=null){
      querySubCycleExecuteCycleStageListReq.setCycleStartTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1879988_1_70407
querySubCycleExecuteCycleStageListReq.setCycleEndTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1879989_1_70407
querySubCycleExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1879991_1_70407
    }

    /*3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）[4718]   */
    Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaObjTargetCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-被评对象目标周期ID不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleStartTime(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期开始时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getCycleEndTime(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-周期结束时间不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsProcessCycleStage(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-是否过程周期阶段不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-是否存档不能为空",false);
Assert.isNull(querySubCycleExecuteCycleStageListReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查询子周期范围内执行周期阶段列表（开始大于等于&结束小于等于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_2 = mOmsExecuteCycleStageService.querySubCycleExecuteCycleStageList(querySubCycleExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_4 =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QueryExecuteCycleLessStartAndGreaterEqualStartListReq queryExecuteCycleLessStartAndGreaterEqualStartListReq=new QueryExecuteCycleLessStartAndGreaterEqualStartListReq();
  queryExecuteCycleLessStartAndGreaterEqualStartListReq.setIsProcessCycleStage("TRUE");//sourceId:1880790_1_70450
queryExecuteCycleLessStartAndGreaterEqualStartListReq.setIsArchive("FALSE");//sourceId:1880793_1_70450
if(omsEvaluationObjectTargetCycle!=null){
      queryExecuteCycleLessStartAndGreaterEqualStartListReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1880791_1_70450
    }
if(reqDto!=null){
      queryExecuteCycleLessStartAndGreaterEqualStartListReq.setCycleStartTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1880788_1_70450
queryExecuteCycleLessStartAndGreaterEqualStartListReq.setCycleEndTime(reqDto.getTargetActualStartTime());//SimpleFieldAssign//sourceId:1880789_1_70450
queryExecuteCycleLessStartAndGreaterEqualStartListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880792_1_70450
    }

    /*3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）[9838]   */
    Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getEvaObjTargetCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getCycleStartTime(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getCycleEndTime(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getIsProcessCycleStage(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleLessStartAndGreaterEqualStartListReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期开始时间所在时间范围的过程执行周期列表（开始小于&结束大于等于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_4 = mOmsExecuteCycleStageService.queryExecuteCycleLessStartAndGreaterEqualStartList(queryExecuteCycleLessStartAndGreaterEqualStartListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_5 = listOmsExecuteCycleStage_4;
           }
List<OmsExecuteCycleStage> listOmsExecuteCycleStage_6 =new ArrayList<>();
    if(omsEvaluationObjectTargetCycle !=null){
          QueryExecuteCycleStageListReq queryExecuteCycleStageListReq=new QueryExecuteCycleStageListReq();
  queryExecuteCycleStageListReq.setIsProcessCycleStage("TRUE");//sourceId:1880541_1_70449
queryExecuteCycleStageListReq.setIsArchive("FALSE");//sourceId:1880543_1_70449
if(omsEvaluationObjectTargetCycle!=null){
      queryExecuteCycleStageListReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1880538_1_70449
    }
if(reqDto!=null){
      queryExecuteCycleStageListReq.setCycleStartTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1880539_1_70449
queryExecuteCycleStageListReq.setCycleEndTime(reqDto.getTargetActualEndtTime());//SimpleFieldAssign//sourceId:1880540_1_70449
queryExecuteCycleStageListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880542_1_70449
    }

    /*3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）[3201]   */
    Assert.isNull(queryExecuteCycleStageListReq.getEvaObjTargetCycleId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getCycleStartTime(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-周期开始时间不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getCycleEndTime(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-周期结束时间不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsProcessCycleStage(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-是否过程周期阶段不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-是否存档不能为空",false);
Assert.isNull(queryExecuteCycleStageListReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07查子周期结束时间所在时间范围的过程执行周期列表（开始小于等于&结束大于）-评价模板ID不能为空",false);
      listOmsExecuteCycleStage_6 = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsExecuteCycleStage_7 = listOmsExecuteCycleStage_6;
           }
    // TODO: 2024/6/22  勿合 
ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto implementMergeTargetContentCustomProcessExecutionCycleComRespDto = null;
    if(listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&& listOmsExecuteCycleStage_2.size()>0 ||listOmsExecuteCycleStage_4 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)&& listOmsExecuteCycleStage_4.size()>0 ||listOmsExecuteCycleStage_6 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)&& listOmsExecuteCycleStage_6.size()>0 ){
          ImplementMergeTargetContentCustomProcessExecutionCycleComReqDto implementMergeTargetContentCustomProcessExecutionCycleComReqDto=new ImplementMergeTargetContentCustomProcessExecutionCycleComReqDto();
  if(listOmsExecuteCycleStage_2!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)&&  listOmsExecuteCycleStage_2 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_2)){
      implementMergeTargetContentCustomProcessExecutionCycleComReqDto.setWithinSubCycleExecuteCycleStageList(listOmsExecuteCycleStage_2.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880484_1_70441
    }
if(listOmsExecuteCycleStage_4!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)&&  listOmsExecuteCycleStage_4 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_4)){
      implementMergeTargetContentCustomProcessExecutionCycleComReqDto.setSubCycleStartTimeExecuteCycleStageList(listOmsExecuteCycleStage_4.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880485_1_70441
    }
if(listOmsExecuteCycleStage_6!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)&&  listOmsExecuteCycleStage_6 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_6)){
      implementMergeTargetContentCustomProcessExecutionCycleComReqDto.setSubCycleEndTimeExecuteCycleStageList(listOmsExecuteCycleStage_6.stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880486_1_70441
    }

    /*D3执行合并目标内容自定义过程执行周期(公共)[9836]   */

      implementMergeTargetContentCustomProcessExecutionCycleComRespDto = implementMergeTargetContentCustomProcessExecutionCycleCom(implementMergeTargetContentCustomProcessExecutionCycleComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((implementMergeTargetContentCustomProcessExecutionCycleComRespDto!= null&&  implementMergeTargetContentCustomProcessExecutionCycleComRespDto.getExecuteCycleStageList() !=null && implementMergeTargetContentCustomProcessExecutionCycleComRespDto.getExecuteCycleStageList().size()>0)) {
        //if(D3执行合并目标内容自定义过程执行周期(公共).执行周期阶段列表数据集条数 大于 0)  70442

List<OmsExecuteCycleStage> listOmsExecuteCycleStage_8 =new ArrayList<>();
    if(implementMergeTargetContentCustomProcessExecutionCycleComRespDto !=null){
          BatchQueryTargetCycleListReq batchQueryTargetCycleListReq=new BatchQueryTargetCycleListReq();
  batchQueryTargetCycleListReq.setIsArchive("FALSE");//sourceId:1880503_1_70444
if(implementMergeTargetContentCustomProcessExecutionCycleComRespDto!=null){
      batchQueryTargetCycleListReq.setExecuteCycleStageList(implementMergeTargetContentCustomProcessExecutionCycleComRespDto.getExecuteCycleStageList());//list-field-assign//sourceId:1880501_1_70444
    }
if(reqDto!=null){
      batchQueryTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1880505_1_70444
    }

    /*3-3-07批量查执行周期列表（by执行周期ID）[2194]   */
    Assert.isNull(batchQueryTargetCycleListReq.getEvaluationTemplateId(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07批量查执行周期列表（by执行周期ID）-评价模板ID不能为空",false);
Assert.isNull(batchQueryTargetCycleListReq.getIsArchive(),"D3分析目标内容自定义过程执行周期范围(公共)-3-3-07批量查执行周期列表（by执行周期ID）-是否存档不能为空",false);
      listOmsExecuteCycleStage_8 = mOmsExecuteCycleStageService.batchQueryTargetCycleList(batchQueryTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(listOmsExecuteCycleStage_8 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_8)&& listOmsExecuteCycleStage_8.size()>0 &&omsExecuteCycleStage !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(listOmsExecuteCycleStage_8!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_8)&&  listOmsExecuteCycleStage_8 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_8)){
      OmsExecuteCycleStage finalOmsExecuteCycleStage1 = omsExecuteCycleStage;
      receptionServiceReq_1.setExecuteCycleStageList(//objList-to-objLists
        listOmsExecuteCycleStage_8.stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      elm.setLastExecuteCycleStageId(item.getLastExecuteCycleStageId());//SimpleFieldAssign//sourceId:376191_2_70445
elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:376193_2_70445
elm.setCycleStandardName(item.getCycleStandardName());//SimpleFieldAssign//sourceId:376194_2_70445
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:376195_2_70445
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:376196_2_70445
elm.setCycleTypeCode(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:376197_2_70445
elm.setCycleTypeInstanceCode(item.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:376198_2_70445
elm.setFillStartTime(item.getFillStartTime());//SimpleFieldAssign//sourceId:376199_2_70445
elm.setFillEndtTime(item.getFillEndtTime());//SimpleFieldAssign//sourceId:376200_2_70445
elm.setEvaluateStartTime(item.getEvaluateStartTime());//SimpleFieldAssign//sourceId:376201_2_70445
elm.setEvaluateEndtTime(item.getEvaluateEndtTime());//SimpleFieldAssign//sourceId:376202_2_70445
elm.setIsProcessCycleStage(item.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:376203_2_70445
elm.setIsDefinedExecuteCycleStage("TRUE");//sourceId:376204_2_70445
elm.setIsCurrentCycle(item.getIsCurrentCycle());//SimpleFieldAssign//sourceId:376205_2_70445
elm.setIsNextCycle(item.getIsNextCycle());//SimpleFieldAssign//sourceId:376206_2_70445
elm.setIsStartCycle(item.getIsStartCycle());//SimpleFieldAssign//sourceId:376207_2_70445
elm.setIsEndCycle(item.getIsEndCycle());//SimpleFieldAssign//sourceId:376208_2_70445
elm.setIsLastCycle(item.getIsLastCycle());//SimpleFieldAssign//sourceId:376209_2_70445
elm.setNextCyclePeriod(item.getNextCyclePeriod());//SimpleFieldAssign//sourceId:376210_2_70445
elm.setIsFatherCycle(item.getIsFatherCycle());//SimpleFieldAssign//sourceId:376212_2_70445
elm.setIsSubCycle(item.getIsSubCycle());//SimpleFieldAssign//sourceId:376213_2_70445
elm.setIsMetaphase(item.getIsMetaphase());//SimpleFieldAssign//sourceId:376214_2_70445
elm.setOrderNumber(item.getOrderNumber());//SimpleFieldAssign//sourceId:376219_2_70445
elm.setEvaTempCreateTime(item.getEvaTempCreateTime());//SimpleFieldAssign//sourceId:376220_2_70445
if(finalOmsExecuteCycleStage1 !=null){
      elm.setRelateExecuteCycleStageId(finalOmsExecuteCycleStage1.getExecuteCycleStageId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376192_2_70445
elm.setRelateContentTypeCode(finalOmsExecuteCycleStage1.getRelateContentTypeCode());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376215_2_70445
elm.setRelateContentId(finalOmsExecuteCycleStage1.getRelateContentId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376216_2_70445
    }
if(reqDto!=null){
      elm.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376211_2_70445
elm.setTargetId(reqDto.getTargetId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376217_2_70445
elm.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:376218_2_70445
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1879897_1_70445
    }

    /*M3-接收出参数据集：执行周期阶段列表[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
      }
    }
AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto retData = new AnalysisTargetContentCustomProcessExecutionCycleRangeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setExecuteCycleStageList(receptionServiceRes_1.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880506_1
    }
if(listOmsExecuteCycleStage_5!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_5)&&  listOmsExecuteCycleStage_5 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_5)){
      retData.setSubCycleStartTimeExecuteCycleStageList(listOmsExecuteCycleStage_5.stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1886824_1
    }
if(listOmsExecuteCycleStage_7!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_7)&&  listOmsExecuteCycleStage_7 !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage_7)){
      retData.setSubCycleEndTimeExecuteCycleStageList(listOmsExecuteCycleStage_7.stream().map(item->item.getCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1886825_1
    }




return retData;
  }
/**
   * D3执行合并目标内容自定义过程执行周期(公共)[9836]
   * gen by moon at 6/22/2024, 9:31:07 PM
   */
  @Trace(operationName = "D3执行合并目标内容自定义过程执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto implementMergeTargetContentCustomProcessExecutionCycleCom(ImplementMergeTargetContentCustomProcessExecutionCycleComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getWithinSubCycleExecuteCycleStageList() !=null && reqDto.getWithinSubCycleExecuteCycleStageList().size()>0&&reqDto!= null&&  reqDto.getSubCycleStartTimeExecuteCycleStageList() !=null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size()>0)) {
        //if((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 大于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 大于 0))  70411

ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto = null;
    ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto=new ImplementUnionMultipleDataSetsComReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getWithinSubCycleExecuteCycleStageList()) {
                DataSetsListOneDto oneItem = new DataSetsListOneDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378802_2_70602
    }

                implementUnionMultipleDataSetsComReqDto.getDataSetsListOne().add(oneItem);
            }//sourceId:1887125_1_70602
//simpleList-to-objLists
    for (String item : reqDto.getSubCycleStartTimeExecuteCycleStageList()) {
                DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70602
    }

                implementUnionMultipleDataSetsComReqDto.getDataSetsListTwo().add(oneItem);
            }//sourceId:1887126_1_70602
    }

    /*D2执行多数据集取并集(公共)[5320]   */

      implementUnionMultipleDataSetsComRespDto = fwCompInterfaceModeClient.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()>0)) {
        //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70430

ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto_2 = null;
    if(implementUnionMultipleDataSetsComRespDto !=null){
          ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto_1=new ImplementUnionMultipleDataSetsComReqDto();
  if(implementUnionMultipleDataSetsComRespDto!= null&&  implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList() !=null&& !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList())){
      implementUnionMultipleDataSetsComReqDto_1.setDataSetsListOne(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList().stream().map(item -> BeanUtil.toBean(item, DataSetsListOneDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1887125_1_70603
    }
if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70603
    }

                implementUnionMultipleDataSetsComReqDto_1.getDataSetsListTwo().add(oneItem);
            }//sourceId:1887126_1_70603
    }

    /*D2执行多数据集取并集(公共)[5320]   */

      implementUnionMultipleDataSetsComRespDto_2 = fwCompInterfaceModeClient.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    if(implementUnionMultipleDataSetsComRespDto_2 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(implementUnionMultipleDataSetsComRespDto_2!= null&&  implementUnionMultipleDataSetsComRespDto_2.getUnionMultipleDataSetsList() !=null&& !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto_2.getUnionMultipleDataSetsList())){
      receptionServiceReq.setExecuteCycleStageList(//objList-to-objLists
        implementUnionMultipleDataSetsComRespDto_2.getUnionMultipleDataSetsList().stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70432
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70432
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()==0)){
       //elseif(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 等于 0)  70433

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(implementUnionMultipleDataSetsComRespDto !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(implementUnionMultipleDataSetsComRespDto!= null&&  implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList() !=null&& !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList())){
      receptionServiceReq_1.setExecuteCycleStageList(//objList-to-objLists
        implementUnionMultipleDataSetsComRespDto.getUnionMultipleDataSetsList().stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70434
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70434
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
      }
else if((reqDto!= null&&  reqDto.getWithinSubCycleExecuteCycleStageList() !=null && reqDto.getWithinSubCycleExecuteCycleStageList().size()>0&&reqDto!= null&&  reqDto.getSubCycleStartTimeExecuteCycleStageList() !=null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size()==0)){
       //elseif((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 大于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 等于 0))  70416

if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()>0)) {
        //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70419

ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto_3 = null;
    ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto_2=new ImplementUnionMultipleDataSetsComReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getWithinSubCycleExecuteCycleStageList()) {
                DataSetsListOneDto oneItem = new DataSetsListOneDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378802_2_70604
    }

                implementUnionMultipleDataSetsComReqDto_2.getDataSetsListOne().add(oneItem);
            }//sourceId:1887125_1_70604
//simpleList-to-objLists
    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70604
    }

                implementUnionMultipleDataSetsComReqDto_2.getDataSetsListTwo().add(oneItem);
            }//sourceId:1887126_1_70604
    }

    /*D2执行多数据集取并集(公共)[5320]   */

      implementUnionMultipleDataSetsComRespDto_3 = fwCompInterfaceModeClient.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_3 = null;
    if(implementUnionMultipleDataSetsComRespDto_3 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(implementUnionMultipleDataSetsComRespDto_3!= null&&  implementUnionMultipleDataSetsComRespDto_3.getUnionMultipleDataSetsList() !=null&& !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto_3.getUnionMultipleDataSetsList())){
      receptionServiceReq_2.setExecuteCycleStageList(//objList-to-objLists
        implementUnionMultipleDataSetsComRespDto_3.getUnionMultipleDataSetsList().stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70422
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70422
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_3 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
      }
else if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()==0)){
       //elseif(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 等于 0)  70420

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getWithinSubCycleExecuteCycleStageList()) {
                ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                if(reqDto!=null){
      oneItem.setExecuteCycleStageId(item);//SimpleFieldAssign//sourceId:376545_2_70423
    }

                receptionServiceReq_3.getExecuteCycleStageList().add(oneItem);
            }//sourceId:1880481_1_70423
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_1 = receptionServiceRes_4;
    }
    }
else if((reqDto!= null&&  reqDto.getWithinSubCycleExecuteCycleStageList() !=null && reqDto.getWithinSubCycleExecuteCycleStageList().size()==0&&reqDto!= null&&  reqDto.getSubCycleStartTimeExecuteCycleStageList() !=null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size()>0)){
       //elseif((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 等于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 大于 0))  70417

if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()>0)) {
        //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70425

ImplementUnionMultipleDataSetsComRespDto implementUnionMultipleDataSetsComRespDto_4 = null;
    ImplementUnionMultipleDataSetsComReqDto implementUnionMultipleDataSetsComReqDto_3=new ImplementUnionMultipleDataSetsComReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getSubCycleStartTimeExecuteCycleStageList()) {
                DataSetsListOneDto oneItem = new DataSetsListOneDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378802_2_70605
    }

                implementUnionMultipleDataSetsComReqDto_3.getDataSetsListOne().add(oneItem);
            }//sourceId:1887125_1_70605
//simpleList-to-objLists
    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                DataSetsListTwoDto oneItem = new DataSetsListTwoDto();
                if(reqDto!=null){
      oneItem.setCustomField(item);//SimpleFieldAssign//sourceId:378807_2_70605
    }

                implementUnionMultipleDataSetsComReqDto_3.getDataSetsListTwo().add(oneItem);
            }//sourceId:1887126_1_70605
    }

    /*D2执行多数据集取并集(公共)[5320]   */

      implementUnionMultipleDataSetsComRespDto_4 = fwCompInterfaceModeClient.implementUnionMultipleDataSetsCom(implementUnionMultipleDataSetsComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
    if(implementUnionMultipleDataSetsComRespDto_4 !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_4=new ImplementElevenReceivingFieldReqDto();
  if(implementUnionMultipleDataSetsComRespDto_4!= null&&  implementUnionMultipleDataSetsComRespDto_4.getUnionMultipleDataSetsList() !=null&& !CollectionUtil.isEmpty(implementUnionMultipleDataSetsComRespDto_4.getUnionMultipleDataSetsList())){
      receptionServiceReq_4.setExecuteCycleStageList(//objList-to-objLists
        implementUnionMultipleDataSetsComRespDto_4.getUnionMultipleDataSetsList().stream().map(item -> {
      ExecuteCycleStageDto elm = new ExecuteCycleStageDto();
      if(item!=null){
      elm.setExecuteCycleStageId(item.getCustomField());//SimpleFieldAssign//sourceId:376545_2_70429
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1880481_1_70429
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_5 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_4);


      receptionServiceRes_1 = receptionServiceRes_5;
           }
      }
else if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()==0)){
       //elseif(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 等于 0)  70426

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_5=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getSubCycleStartTimeExecuteCycleStageList()) {
                ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                if(reqDto!=null){
      oneItem.setExecuteCycleStageId(item);//SimpleFieldAssign//sourceId:376545_2_70427
    }

                receptionServiceReq_5.getExecuteCycleStageList().add(oneItem);
            }//sourceId:1880481_1_70427
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_6 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_5);


      receptionServiceRes_1 = receptionServiceRes_6;
    }
    }
else if((reqDto!= null&&  reqDto.getWithinSubCycleExecuteCycleStageList() !=null && reqDto.getWithinSubCycleExecuteCycleStageList().size()==0&&reqDto!= null&&  reqDto.getSubCycleStartTimeExecuteCycleStageList() !=null && reqDto.getSubCycleStartTimeExecuteCycleStageList().size()==0)){
       //elseif((D3执行合并目标内容自定义过程执行周期(公共).子周期时间范围内执行周期列表数据集条数 等于 0 and D3执行合并目标内容自定义过程执行周期(公共).子周期开始时间所在执行周期列表数据集条数 等于 0))  70436

if((reqDto!= null&&  reqDto.getSubCycleEndTimeExecuteCycleStageList() !=null && reqDto.getSubCycleEndTimeExecuteCycleStageList().size()>0)) {
        //if(D3执行合并目标内容自定义过程执行周期(公共).子周期结束时间所在执行周期列表数据集条数 大于 0)  70438

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_7 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_6=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getSubCycleEndTimeExecuteCycleStageList()) {
                ExecuteCycleStageDto oneItem = new ExecuteCycleStageDto();
                if(reqDto!=null){
      oneItem.setExecuteCycleStageId(item);//SimpleFieldAssign//sourceId:376545_2_70440
    }

                receptionServiceReq_6.getExecuteCycleStageList().add(oneItem);
            }//sourceId:1880481_1_70440
    }

    /*M3-接收出参：执行周期阶段数据集[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_7 = nbCustomExecutionCycle.implementElevenReceivingField(receptionServiceReq_6);


      receptionServiceRes_1 = receptionServiceRes_7;
      }
else{
       //else  70447

//异常结束 70448
      throw new BizException("220100389","对不起，找不到周期ID~",false);
    }
    }
ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto retData = new ImplementMergeTargetContentCustomProcessExecutionCycleComRespDto();
  if(receptionServiceRes_1!= null&&  receptionServiceRes_1.getExecuteCycleStageList() !=null&& !CollectionUtil.isEmpty(receptionServiceRes_1.getExecuteCycleStageList())){
      retData.setExecuteCycleStageList(receptionServiceRes_1.getExecuteCycleStageList().stream().map(item->item.getExecuteCycleStageId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1880483_1
    }




return retData;
  }
/**
   * D3执行修正子周期开始或结束的自定义过程执行周期(公共)[9847]
   * gen by moon at 7/6/2024, 11:57:32 PM
   */
  @Trace(operationName = "D3执行修正子周期开始或结束的自定义过程执行周期(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementModifyStartOrEndDefinedExecCycleComRespDto implementModifyStartOrEndDefinedExecCycleCom(ImplementModifyStartOrEndDefinedExecCycleComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getExecuteCycleStageList() !=null && reqDto.getExecuteCycleStageList().size()>0)) {
        //if(D3执行修正子周期开始或结束的自定义过程执行周期(公共).执行周期阶段列表数据集条数 大于 0)  70594

List<OmsExecuteCycleStage> listOmsExecuteCycleStage =new ArrayList<>();
    BatchQueryExecuteCycleStageReq batchQueryExecuteCycleStageReq=new BatchQueryExecuteCycleStageReq();
  if(reqDto!=null){
      batchQueryExecuteCycleStageReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList());//list-field-assign//sourceId:1887092_1_70595
batchQueryExecuteCycleStageReq.setIsProcessCycleStage(reqDto.getIsProcessCycleStage());//SimpleFieldAssign//sourceId:1887100_1_70595
batchQueryExecuteCycleStageReq.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:1887110_1_70595
batchQueryExecuteCycleStageReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1887111_1_70595
batchQueryExecuteCycleStageReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1887095_1_70595
    }

    /*3-3-07批量查询执行周期阶段by周期ID[3149]   */

      listOmsExecuteCycleStage = mOmsExecuteCycleStageService.batchQueryExecuteCycleStage(batchQueryExecuteCycleStageReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsExecuteCycleStage!= null&&  listOmsExecuteCycleStage !=null && listOmsExecuteCycleStage.size()>0&&reqDto!= null&& reqDto.getCycleStartTime() != null )) {
        //if((3-3-07批量查询执行周期阶段by周期ID.执行周期阶段列表数据集条数 大于 0 and D3执行修正子周期开始或结束的自定义过程执行周期(公共).周期开始时间 值不等于空 ))  70596

boolean bOOLEAN ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_2=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listOmsExecuteCycleStage_2 = //objList-to-objLists
        listOmsExecuteCycleStage.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:378783_2_70598
elm.setCycleEndTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:378787_2_70598
elm.setFillEndtTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:390023_2_70598
elm.setEvaluateEndtTime(item.getCycleEndTime());//SimpleFieldAssign//sourceId:390025_2_70598
if(reqDto!=null){
      elm.setCycleStartTime(reqDto.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:378786_2_70598
elm.setFillStartTime(reqDto.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390022_2_70598
elm.setEvaluateStartTime(reqDto.getCycleStartTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390024_2_70598
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1887113_1_70598
    }

    /*3-3-07批量改执行周期阶段[3150]   */

      bOOLEAN = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_2)/*vcase invoke 本地 method 方法调用;*/;



           }
      }
else if((listOmsExecuteCycleStage!= null&&  listOmsExecuteCycleStage !=null && listOmsExecuteCycleStage.size()>0&&reqDto!= null&& reqDto.getCycleEndTime() != null )){
       //elseif((3-3-07批量查询执行周期阶段by周期ID.执行周期阶段列表数据集条数 大于 0 and D3执行修正子周期开始或结束的自定义过程执行周期(公共).周期结束时间 值不等于空 ))  70597

boolean bOOLEAN_1 ;
    if(listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&& listOmsExecuteCycleStage.size()>0 ){
          List<OmsExecuteCycleStage> listOmsExecuteCycleStage_3=new ArrayList<>();
  if(listOmsExecuteCycleStage!= null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)&&  listOmsExecuteCycleStage !=null&& !CollectionUtil.isEmpty(listOmsExecuteCycleStage)){
      listOmsExecuteCycleStage_3 = //objList-to-objLists
        listOmsExecuteCycleStage.stream().map(item -> {
      OmsExecuteCycleStage elm = new OmsExecuteCycleStage();
      elm.setExecuteCycleStageId(item.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:378783_2_70599
elm.setCycleStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:378786_2_70599
elm.setFillStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:390022_2_70599
elm.setEvaluateStartTime(item.getCycleStartTime());//SimpleFieldAssign//sourceId:390024_2_70599
if(reqDto!=null){
      elm.setCycleEndTime(reqDto.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:378787_2_70599
elm.setFillEndtTime(reqDto.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390023_2_70599
elm.setEvaluateEndtTime(reqDto.getCycleEndTime());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:390025_2_70599
    }
        return elm;
      }).collect(Collectors.toList());//objList-to-objLists//sourceId:1887113_1_70599
    }

    /*3-3-07批量改执行周期阶段[3150]   */

      bOOLEAN_1 = mOmsExecuteCycleStageService.batchUpdateExecuteCycleStage(listOmsExecuteCycleStage_3)/*vcase invoke 本地 method 方法调用;*/;



           }
    }
      }
ImplementModifyStartOrEndDefinedExecCycleComRespDto retData = new ImplementModifyStartOrEndDefinedExecCycleComRespDto();





return retData;
  }
/**
   * D3查询被评对象目标周期详情（开始小于等于结束时间大于等于）(公共)[10221]
   * gen by moon at 9/18/2024, 7:31:54 PM
   */
  @Trace(operationName = "D3查询被评对象目标周期详情（开始小于等于结束时间大于等于）(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryEvaObjTargetCycleEqualStartAndGreaterDetailComRespDto queryEvaObjTargetCycleEqualStartAndGreaterDetailCom(QueryEvaObjTargetCycleEqualStartAndGreaterDetailComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
//步骤0: 3-3-09查询被评对象目标周期详情（开始小于等于结束时间大于等于） - queryEvaObjTargetCycleEqualStartAndGreaterDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq queryEvaObjTargetCycleEqualStartAndGreaterDetailReq=new QueryEvaObjTargetCycleEqualStartAndGreaterDetailReq();
  if(reqDto!=null){
      queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2002359_1
      queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:2001312_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:2001313_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:2001314_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2001326_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2004610_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:2001325_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:2004603_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:2001315_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:2001316_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setCycleEndTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:2001317_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:2005670_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2001318_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:2001319_1
queryEvaObjTargetCycleEqualStartAndGreaterDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:2001371_1
    }

    /*3-3-09查询被评对象目标周期详情（开始小于等于结束时间大于等于）[9460]   */

      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleEqualStartAndGreaterDetail(queryEvaObjTargetCycleEqualStartAndGreaterDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

QueryEvaObjTargetCycleEqualStartAndGreaterDetailComRespDto retData = new QueryEvaObjTargetCycleEqualStartAndGreaterDetailComRespDto();
  if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:2001340_1
retData.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:2001341_1
retData.setCycleId(omsEvaluationObjectTargetCycle_1.getCycleId());//SimpleFieldAssign//sourceId:2001342_1
retData.setCyclelAlias(omsEvaluationObjectTargetCycle_1.getCyclelAlias());//SimpleFieldAssign//sourceId:2001343_1
retData.setCycleStartTime(omsEvaluationObjectTargetCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:2001344_1
retData.setCycleEndTime(omsEvaluationObjectTargetCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:2001345_1
retData.setCycleTypeCode(omsEvaluationObjectTargetCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:2001346_1
retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:2001347_1
    }




return retData;
  }
  //
}
